2.0alpha1-netstandard2.0_vs_2.0alpha2-netstandard2.0.apilist.diff
--- Smdn.Net.Pop3.Client-2.0alpha1-netstandard2.0.apilist.cs 2019-03-23 14:50:19.000000000 +0900
+++ Smdn.Net.Pop3.Client-2.0alpha2-netstandard2.0.apilist.cs 2019-03-23 14:50:23.000000000 +0900
@@ -1,936 +1,1012 @@
-// Smdn.Net.Pop3.Client-2.0alpha1 (netstandard2.0)
+// Smdn.Net.Pop3.Client-2.0alpha2 (netstandard2.0)
// Name: Smdn.Net.Pop3.Client
// TargetFramework: .NETStandard,Version=v2.0
// AssemblyVersion: 2.0.0.0
-// InformationalVersion: 2.0alpha1 (netstandard2.0)
+// InformationalVersion: 2.0alpha2 (netstandard2.0)
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Runtime.Serialization;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Smdn.IO.Streams.LineOriented;
using Smdn.Net.Connection;
-using Smdn.Net.MessageAccessProtocols;
+using Smdn.Net.MessageAccessProtocols.Strings;
using Smdn.Net.Pop3;
using Smdn.Net.Pop3.Client;
using Smdn.Net.Pop3.Protocol;
using Smdn.Net.Pop3.Protocol.DataStructures;
using Smdn.Net.Pop3.Protocol.Session;
using Smdn.Net.Pop3.Protocol.Strings;
using Smdn.Net.Pop3.Protocol.Transmission;
using Smdn.Net.Pop3.Urls;
using Smdn.Security.Authentication.Sasl.Client;
using Smdn.Text;
namespace Smdn.Net.Pop3 {
[Serializable]
public class PopException : Exception {
protected PopException(SerializationInfo info, StreamingContext context) {}
public PopException() {}
public PopException(string message) {}
public PopException(string message, Exception innerException) {}
}
}
namespace Smdn.Net.Pop3.Client {
public class PopClient : IDisposable {
public PopClient() {}
public PopClient(PopClientProfile profile) {}
public PopClient(Uri authority) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public PopClient(string host, bool securePort, string userName) {}
public PopClient(string host, int port = -1, bool securePort = false, string userName = null, string authType = null, int timeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool useTlsIfAvailable = true, IEnumerable<string> usingSaslMechanisms = null, bool allowInsecureLogin = false, bool allowStandardLogin = true, bool allowAllowApopLogin = true) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public PopClient(string host, int port, string userName) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public PopClient(string host, int port, string userName, string authType) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public PopClient(string host, string userName) {}
public bool DeleteAfterRetrieve { get; set; }
public bool IsBusy { get; }
public bool IsConnected { get; }
public bool IsSecureSession { get; }
public long MessageCount { get; }
public PopClientProfile Profile { get; }
public int ReceiveTimeout { get; set; }
public int SendTimeout { get; set; }
public IReadOnlyStringSet<PopCapability> ServerCapabilities { get; }
public int Timeout { get; set; }
public long TotalSize { get; }
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public IAsyncResult BeginConnect(ICredentialsByHost credentials, AsyncCallback asyncCallback, object asyncState) {}
public IAsyncResult BeginConnect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, AsyncCallback asyncCallback, object asyncState) {}
public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public IAsyncResult BeginConnect(string password, AsyncCallback asyncCallback, object asyncState) {}
public IAsyncResult BeginConnect(string password, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
public void CancelDelete() {}
public Task CancelDeleteAsync() {}
public void Connect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
public void Connect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
public void Connect(string password, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
public Task ConnectAsync(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
public Task ConnectAsync(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
public Task ConnectAsync(string password, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
public void Disconnect(bool logout = false) {}
public IReadOnlyList<TResult> DownloadAllMessagesAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public IReadOnlyList<TResult> DownloadAllMessagesAs<TResult>(Converter<Stream, TResult> converter) {}
public static IReadOnlyList<TResult> DownloadAllMessagesAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
public static IReadOnlyList<TResult> DownloadAllMessagesAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
public Task<IReadOnlyList<TResult>> DownloadAllMessagesAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public Task<IReadOnlyList<TResult>> DownloadAllMessagesAsAsync<TResult>(Converter<Stream, TResult> converter) {}
public IReadOnlyList<string> DownloadAllMessagesAsText(Encoding encoding) {}
public static IReadOnlyList<string> DownloadAllMessagesAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
public Task<IReadOnlyList<string>> DownloadAllMessagesAsTextAsync(Encoding encoding) {}
public IReadOnlyList<FileInfo> DownloadAllMessagesToDirectory(string directory) {}
public static IReadOnlyList<FileInfo> DownloadAllMessagesToDirectory(Uri popUrl, string password, bool deleteAfterDownload, string directory) {}
public Task<IReadOnlyList<FileInfo>> DownloadAllMessagesToDirectoryAsync(string directory) {}
public IReadOnlyList<FileInfo> DownloadAllMessagesToFiles(Func<PopMessage, string> selectFileName) {}
public static IReadOnlyList<FileInfo> DownloadAllMessagesToFiles(Uri popUrl, string password, bool deleteAfterDownload, Func<PopMessage, string> selectFileName) {}
public Task<IReadOnlyList<FileInfo>> DownloadAllMessagesToFilesAsync(Func<PopMessage, string> selectFileName) {}
public TResult DownloadFirstMessageAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public TResult DownloadFirstMessageAs<TResult>(Converter<Stream, TResult> converter) {}
public static TResult DownloadFirstMessageAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
public static TResult DownloadFirstMessageAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
public Task<TResult> DownloadFirstMessageAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public Task<TResult> DownloadFirstMessageAsAsync<TResult>(Converter<Stream, TResult> converter) {}
public byte[] DownloadFirstMessageAsByteArray() {}
public static byte[] DownloadFirstMessageAsByteArray(Uri popUrl, string password, bool deleteAfterDownload) {}
public Task<byte[]> DownloadFirstMessageAsByteArrayAsync() {}
public Stream DownloadFirstMessageAsStream() {}
public static Stream DownloadFirstMessageAsStream(Uri popUrl, string password, bool deleteAfterDownload) {}
public Task<Stream> DownloadFirstMessageAsStreamAsync() {}
public static string DownloadFirstMessageAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
public string DownloadFirstMessageAsText(Encoding encoding) {}
public Task<string> DownloadFirstMessageAsTextAsync(Encoding encoding) {}
public FileInfo DownloadFirstMessageToFile(string path) {}
public static FileInfo DownloadFirstMessageToFile(Uri popUrl, string password, bool deleteAfterDownload, string path) {}
public Task<FileInfo> DownloadFirstMessageToFileAsync(string path) {}
public TResult DownloadLastMessageAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public TResult DownloadLastMessageAs<TResult>(Converter<Stream, TResult> converter) {}
public static TResult DownloadLastMessageAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
public static TResult DownloadLastMessageAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
public Task<TResult> DownloadLastMessageAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public Task<TResult> DownloadLastMessageAsAsync<TResult>(Converter<Stream, TResult> converter) {}
public byte[] DownloadLastMessageAsByteArray() {}
public static byte[] DownloadLastMessageAsByteArray(Uri popUrl, string password, bool deleteAfterDownload) {}
public Task<byte[]> DownloadLastMessageAsByteArrayAsync() {}
public Stream DownloadLastMessageAsStream() {}
public static Stream DownloadLastMessageAsStream(Uri popUrl, string password, bool deleteAfterDownload) {}
public Task<Stream> DownloadLastMessageAsStreamAsync() {}
public static string DownloadLastMessageAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
public string DownloadLastMessageAsText(Encoding encoding) {}
public Task<string> DownloadLastMessageAsTextAsync(Encoding encoding) {}
public FileInfo DownloadLastMessageToFile(string path) {}
public static FileInfo DownloadLastMessageToFile(Uri popUrl, string password, bool deleteAfterDownload, string path) {}
public Task<FileInfo> DownloadLastMessageToFileAsync(string path) {}
public TResult DownloadMessageAs<T, TResult>(long messageNumber, Func<Stream, T, TResult> read, T arg) {}
public TResult DownloadMessageAs<TResult>(long messageNumber, Converter<Stream, TResult> converter) {}
public Task<TResult> DownloadMessageAsAsync<T, TResult>(long messageNumber, Func<Stream, T, TResult> read, T arg) {}
public Task<TResult> DownloadMessageAsAsync<TResult>(long messageNumber, Converter<Stream, TResult> converter) {}
public byte[] DownloadMessageAsByteArray(long messageNumber) {}
public Task<byte[]> DownloadMessageAsByteArrayAsync(long messageNumber) {}
public Stream DownloadMessageAsStream(long messageNumber) {}
public Task<Stream> DownloadMessageAsStreamAsync(long messageNumber) {}
public string DownloadMessageAsText(long messageNumber, Encoding encoding) {}
public Task<string> DownloadMessageAsTextAsync(long messageNumber, Encoding encoding) {}
public FileInfo DownloadMessageToFile(long messageNumber, string path) {}
public Task<FileInfo> DownloadMessageToFileAsync(long messageNumber, string path) {}
public void EndConnect(IAsyncResult asyncResult) {}
public PopMessage GetFirstMessage(bool getUniqueId = false) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<PopMessage> GetFirstMessageAsync(CancellationToken cancellationToken) {}
public Task<PopMessage> GetFirstMessageAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
public PopMessage GetLastMessage(bool getUniqueId = false) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<PopMessage> GetLastMessageAsync(CancellationToken cancellationToken) {}
public Task<PopMessage> GetLastMessageAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
public PopMessage GetMessage(long messageNumber, bool getUniqueId = false) {}
public PopMessage GetMessage(string uniqueId) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<PopMessage> GetMessageAsync(long messageNumber, CancellationToken cancellationToken) {}
public Task<PopMessage> GetMessageAsync(long messageNumber, bool getUniqueId = false, CancellationToken cancellationToken = default) {}
public Task<PopMessage> GetMessageAsync(string uniqueId, CancellationToken cancellationToken = default) {}
public static long GetMessageCount(Uri popUrl, string password) {}
public IReadOnlyList<PopMessage> GetMessages(bool getUniqueId = false) {}
[Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(CancellationToken cancellationToken) {}
public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
public void KeepAlive() {}
public Task KeepAliveAsync() {}
public void Logout() {}
void IDisposable.Dispose() {}
public override string ToString() {}
public void UpdateStatus() {}
public Task UpdateStatusAsync() {}
}
[Serializable]
public class PopClientProfile :
ICloneable,
IPopSessionProfile,
ISerializable
{
protected PopClientProfile(SerializationInfo info, StreamingContext context) {}
public PopClientProfile() {}
public PopClientProfile(Uri authority) {}
public PopClientProfile(string host, int port = -1, bool securePort = false, string userName = null, string authType = null, int timeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool useTlsIfAvailable = true, IEnumerable<string> usingSaslMechanisms = null, bool allowInsecureLogin = false, bool allowStandardLogin = true, bool allowApopLogin = true) {}
public bool AllowApopLogin { get; set; }
public bool AllowInsecureLogin { get; set; }
public bool AllowStandardLogin { get; set; }
public string AuthType { get; set; }
public Uri Authority { get; }
public string Host { get; set; }
public int Port { get; set; }
public int ReceiveTimeout { get; set; }
public bool SecurePort { get; set; }
public int SendTimeout { get; set; }
ICredentialsByHost IPopSessionProfile.Credentials { get; }
IReadOnlyList<string> IPopSessionProfile.UsingSaslMechanisms { get; }
public int Timeout { get; set; }
public bool UseTlsIfAvailable { get; set; }
public string UserName { get; set; }
public IList<string> UsingSaslMechanisms { get; }
public PopClientProfile Clone() {}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
public void SetUsingSaslMechanisms(IEnumerable<string> mechanisms) {}
object ICloneable.Clone() {}
}
public sealed class PopMessage {
public PopClient Client { get; }
public bool IsMarkedAsDeleted { get; }
public long Length { get; }
public long MessageNumber { get; }
public string UniqueId { get; }
public string GetUniqueId() {}
public Task<string> GetUniqueIdAsync() {}
public void MarkAsDeleted() {}
public Task MarkAsDeletedAsync() {}
- public Stream OpenRead() {}
- public Stream OpenRead(int maxLines) {}
- public Task<Stream> OpenReadAsync() {}
+ public Stream OpenRead(int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<Stream> OpenReadAsync(CancellationToken cancellationToken) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<Stream> OpenReadAsync(CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<Stream> OpenReadAsync(IProgress<PopMessageRetrieveProgressInfo> progress) {}
- public Task<Stream> OpenReadAsync(int maxLines) {}
- public Task<Stream> OpenReadAsync(int maxLines, CancellationToken cancellationToken) {}
- public Task<Stream> OpenReadAsync(int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ public Task<Stream> OpenReadAsync(int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<Stream> OpenReadAsync(int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
- public StreamReader OpenText() {}
- public StreamReader OpenText(Encoding encoding) {}
- public StreamReader OpenText(Encoding encoding, int maxLines) {}
+ public StreamReader OpenText(Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public StreamReader OpenText(int maxLines) {}
- public Task<StreamReader> OpenTextAsync() {}
- public Task<StreamReader> OpenTextAsync(Encoding charset) {}
- public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines) {}
- public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
- public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ public Task<StreamReader> OpenTextAsync(Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<StreamReader> OpenTextAsync(int maxLines) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public byte[] ReadAllBytes() {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public byte[] ReadAllBytes(int maxLines) {}
+ [Obsolete("use ReadAsByteArrayAsync() instead")]
public Task<byte[]> ReadAllBytesAsync() {}
+ [Obsolete("use ReadAsByteArrayAsync() instead")]
public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken) {}
+ [Obsolete("use ReadAsByteArrayAsync() instead")]
public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("use ReadAsByteArrayAsync() instead")]
public Task<byte[]> ReadAllBytesAsync(IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("use ReadAsByteArrayAsync() instead")]
public Task<byte[]> ReadAllBytesAsync(int maxLines) {}
+ [Obsolete("use ReadAsByteArrayAsync() instead")]
public Task<byte[]> ReadAllBytesAsync(int maxLines, CancellationToken cancellationToken) {}
+ [Obsolete("use ReadAsByteArrayAsync() instead")]
public Task<byte[]> ReadAllBytesAsync(int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("use ReadAsByteArrayAsync() instead")]
public Task<byte[]> ReadAllBytesAsync(int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("use ReadAsStringLines() instead")]
public string[] ReadAllLines() {}
+ [Obsolete("use ReadAsStringLines() instead")]
public string[] ReadAllLines(Encoding encoding) {}
+ [Obsolete("use ReadAsStringLines() instead")]
public string[] ReadAllLines(Encoding encoding, int maxLines) {}
+ [Obsolete("use ReadAsStringLines() instead")]
public string[] ReadAllLines(int maxLines) {}
+ [Obsolete("use ReadAsStringLinesAsync() instead")]
public Task<string[]> ReadAllLinesAsync() {}
+ [Obsolete("use ReadAsStringLinesAsync() instead")]
public Task<string[]> ReadAllLinesAsync(Encoding charset) {}
+ [Obsolete("use ReadAsStringLinesAsync() instead")]
public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines) {}
+ [Obsolete("use ReadAsStringLinesAsync() instead")]
public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
+ [Obsolete("use ReadAsStringLinesAsync() instead")]
public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("use ReadAsStringLinesAsync() instead")]
public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("use ReadAsStringLinesAsync() instead")]
public Task<string[]> ReadAllLinesAsync(int maxLines) {}
+ [Obsolete("use ReadAsString() instead")]
public string ReadAllText() {}
+ [Obsolete("use ReadAsString() instead")]
public string ReadAllText(Encoding encoding) {}
+ [Obsolete("use ReadAsString() instead")]
public string ReadAllText(Encoding encoding, int maxLines) {}
+ [Obsolete("use ReadAsString() instead")]
public string ReadAllText(int maxLines) {}
+ [Obsolete("use ReadAsStringAsync() instead")]
public Task<string> ReadAllTextAsync() {}
+ [Obsolete("use ReadAsStringAsync() instead")]
public Task<string> ReadAllTextAsync(Encoding charset) {}
+ [Obsolete("use ReadAsStringAsync() instead")]
public Task<string> ReadAllTextAsync(Encoding charset, int maxLines) {}
+ [Obsolete("use ReadAsStringAsync() instead")]
public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
+ [Obsolete("use ReadAsStringAsync() instead")]
public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("use ReadAsStringAsync() instead")]
public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("use ReadAsStringAsync() instead")]
public Task<string> ReadAllTextAsync(int maxLines) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<T, TResult>(int maxLines, Func<Stream, T, TResult> read, T arg) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<T1, T2, T3, T4, TResult>(Func<Stream, T1, T2, T3, T4, TResult> read, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<T1, T2, T3, T4, TResult>(int maxLines, Func<Stream, T1, T2, T3, T4, TResult> read, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<T1, T2, T3, TResult>(Func<Stream, T1, T2, T3, TResult> read, T1 arg1, T2 arg2, T3 arg3) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<T1, T2, T3, TResult>(int maxLines, Func<Stream, T1, T2, T3, TResult> read, T1 arg1, T2 arg2, T3 arg3) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<T1, T2, TResult>(Func<Stream, T1, T2, TResult> read, T1 arg1, T2 arg2) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<T1, T2, TResult>(int maxLines, Func<Stream, T1, T2, TResult> read, T1 arg1, T2 arg2) {}
+ public TResult ReadAs<TArg, TResult>(Func<Stream, TArg, TResult> converter, TArg arg, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ public TResult ReadAs<TArg, TResult>(Func<StreamReader, TArg, TResult> converter, TArg arg, Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<TResult>(Converter<Stream, TResult> converter) {}
+ public TResult ReadAs<TResult>(Converter<Stream, TResult> converter, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<TResult>(Converter<StreamReader, TResult> converter) {}
+ public TResult ReadAs<TResult>(Converter<StreamReader, TResult> converter, Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<TResult>(Encoding encoding, Converter<StreamReader, TResult> converter) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<TResult>(Encoding encoding, int maxLines, Converter<StreamReader, TResult> converter) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<TResult>(int maxLines, Converter<Stream, TResult> converter) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public TResult ReadAs<TResult>(int maxLines, Converter<StreamReader, TResult> converter) {}
+ public Task<TResult> ReadAsAsync<TArg, TResult>(Func<Stream, TArg, Task<TResult>> converter, TArg arg, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ public Task<TResult> ReadAsAsync<TArg, TResult>(Func<StreamReader, TArg, Task<TResult>> converter, TArg arg, Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, Task<TResult>> converter, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter) {}
+ public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, Task<TResult>> converter, Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, Converter<StreamReader, TResult> converter) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<StreamReader, TResult> converter) {}
+ public byte[] ReadAsByteArray(int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ public Task<byte[]> ReadAsByteArrayAsync(int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ public string ReadAsString(Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ public Task<string> ReadAsStringAsync(Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ public IReadOnlyList<string> ReadAsStringLines(Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ public Task<IReadOnlyList<string>> ReadAsStringLinesAsync(Encoding charset = null, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("use ReadAsStringLines() instead")]
public IEnumerable<string> ReadLines() {}
+ [Obsolete("use ReadAsStringLines() instead")]
public IEnumerable<string> ReadLines(Encoding encoding) {}
+ [Obsolete("use ReadAsStringLines() instead")]
public IEnumerable<string> ReadLines(Encoding encoding, int maxLines) {}
+ [Obsolete("use ReadAsStringLines() instead")]
public IEnumerable<string> ReadLines(int maxLines) {}
- public void Save(string path) {}
- public void Save(string path, int maxLines) {}
- public Task SaveAsync(string path) {}
+ public void Save(string path, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task SaveAsync(string path, CancellationToken cancellationToken) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task SaveAsync(string path, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task SaveAsync(string path, IProgress<PopMessageRetrieveProgressInfo> progress) {}
- public Task SaveAsync(string path, int maxLines) {}
- public Task SaveAsync(string path, int maxLines, CancellationToken cancellationToken) {}
- public Task SaveAsync(string path, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ public Task SaveAsync(string path, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task SaveAsync(string path, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public override string ToString() {}
public bool TryGetUniqueId(out string uniqueId) {}
- public void WriteTo(BinaryWriter writer) {}
- public void WriteTo(BinaryWriter writer, int maxLines) {}
- public void WriteTo(Stream stream) {}
- public void WriteTo(Stream stream, int maxLines) {}
- public Task WriteToAsync(BinaryWriter writer) {}
+ public void WriteTo(BinaryWriter writer, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ public void WriteTo(Stream stream, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task WriteToAsync(BinaryWriter writer, IProgress<PopMessageRetrieveProgressInfo> progress) {}
- public Task WriteToAsync(BinaryWriter writer, int maxLines) {}
- public Task WriteToAsync(BinaryWriter writer, int maxLines, CancellationToken cancellationToken) {}
- public Task WriteToAsync(BinaryWriter writer, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ public Task WriteToAsync(BinaryWriter writer, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task WriteToAsync(BinaryWriter writer, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
- public Task WriteToAsync(Stream stream) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task WriteToAsync(Stream stream, CancellationToken cancellationToken) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task WriteToAsync(Stream stream, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task WriteToAsync(Stream stream, IProgress<PopMessageRetrieveProgressInfo> progress) {}
- public Task WriteToAsync(Stream stream, int maxLines) {}
- public Task WriteToAsync(Stream stream, int maxLines, CancellationToken cancellationToken) {}
- public Task WriteToAsync(Stream stream, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
+ public Task WriteToAsync(Stream stream, int maxLines = -1, CancellationToken cancellationToken = default, IProgress<PopMessageRetrieveProgressInfo> progress = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task WriteToAsync(Stream stream, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
}
[Serializable]
public class PopMessageDeletedException : PopProtocolViolationException {
protected PopMessageDeletedException(SerializationInfo info, StreamingContext context) {}
public PopMessageDeletedException() {}
public PopMessageDeletedException(long messageNumber) {}
public PopMessageDeletedException(string message, long messageNumber) {}
public long MessageNumber { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public class PopMessageNotFoundException : PopException {
protected PopMessageNotFoundException(SerializationInfo info, StreamingContext context) {}
public PopMessageNotFoundException() {}
public PopMessageNotFoundException(long messageNumber) {}
public PopMessageNotFoundException(string uniqueId) {}
public long MessageNumber { get; }
public string UniqueId { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
public static class PopSslConnection {
public static LocalCertificateSelectionCallback ClientCertificateSelectionCallback { get; set; }
public static X509Certificate2Collection ClientCertificates { get; }
public static RemoteCertificateValidationCallback DangerousAcceptAnyServerCertificateValidator { get; }
public static SslProtocols EnabledSslProtocols { get; set; }
public static RemoteCertificateValidationCallback ServerCertificateValidationCallback { get; set; }
}
public struct PopMessageRetrieveProgressInfo {
public PopMessageRetrieveProgressInfo(long retrievedOctetCount, long retrievedLineCount, long totalOctetCount, CancellationToken cancellationToken) {}
public CancellationToken CancellationToken { get; }
public int ProgressPercentage { get; }
public long RetrievedLineCount { get; }
public long RetrievedOctetCount { get; }
public long TotalOctetCount { get; }
public override string ToString() {}
}
}
namespace Smdn.Net.Pop3.Protocol {
public static class ApopDigest {
public static string Calculate(ByteString timestamp, ByteString sharedSecret) {}
public static string Calculate(string timestamp, string sharedSecret) {}
}
[Serializable]
public class PopAuthenticationException : PopErrorResponseException {
protected PopAuthenticationException(SerializationInfo info, StreamingContext context) {}
public PopAuthenticationException() {}
public PopAuthenticationException(PopCommandResult result) {}
}
public sealed class PopAuthenticationMechanism :
- PopStringEnum,
+ PopEnumValue,
IEquatable<PopAuthenticationMechanism>
{
public static readonly PopAuthenticationMechanism Anonymous; // = "ANONYMOUS"
public static readonly PopAuthenticationMechanism Apop; // = "+APOP"
public static readonly PopAuthenticationMechanism CRAMMD5; // = "CRAM-MD5"
public static readonly PopAuthenticationMechanism DigestMD5; // = "DIGEST-MD5"
public static readonly PopAuthenticationMechanism External; // = "EXTERNAL"
public static readonly PopAuthenticationMechanism Gssapi; // = "GSSAPI"
public static readonly PopAuthenticationMechanism IsoIec9798_M_DSA_SHA1; // = "9798-M-DSA-SHA1"
public static readonly PopAuthenticationMechanism IsoIec9798_M_ECDSA_SHA1; // = "9798-M-ECDSA-SHA1"
public static readonly PopAuthenticationMechanism IsoIec9798_M_RSA_SHA1_ENC; // = "9798-M-RSA-SHA1-ENC"
public static readonly PopAuthenticationMechanism IsoIec9798_U_DSA_SHA1; // = "9798-U-DSA-SHA1"
public static readonly PopAuthenticationMechanism IsoIec9798_U_ECDSA_SHA1; // = "9798-U-ECDSA-SHA1"
public static readonly PopAuthenticationMechanism IsoIec9798_U_RSA_SHA1_ENC; // = "9798-U-RSA-SHA1-ENC"
public static readonly PopAuthenticationMechanism KerberosV4; // = "KERBEROS_V4"
public static readonly PopAuthenticationMechanism KerberosV5; // = "KERBEROS_V5"
public static readonly PopAuthenticationMechanism Login; // = "LOGIN"
public static readonly PopAuthenticationMechanism NTLM; // = "NTLM"
public static readonly PopAuthenticationMechanism OTP; // = "OTP"
public static readonly PopAuthenticationMechanism Plain; // = "PLAIN"
public static readonly PopAuthenticationMechanism SKey; // = "SKEY"
public static readonly PopAuthenticationMechanism SecureID; // = "SECURID"
public static readonly PopAuthenticationMechanism SelectAppropriate; // = "*"
public PopAuthenticationMechanism(string mechanismName, PopCapability requiredCapability = null) {}
public static IReadOnlyStringSet<PopAuthenticationMechanism> AllMechanisms { get; }
public PopCapability RequiredCapability { get; }
public bool Equals(PopAuthenticationMechanism other) {}
public override bool Equals(object obj) {}
public override int GetHashCode() {}
public static bool operator == (PopAuthenticationMechanism x, PopAuthenticationMechanism y) {}
public static bool operator != (PopAuthenticationMechanism x, PopAuthenticationMechanism y) {}
}
[Serializable]
public sealed class PopCapability :
- PopStringEnum,
+ PopEnumValue,
IEquatable<PopCapability>
{
public static readonly PopCapability AuthRespCode; // = "AUTH-RESP-CODE"
public static readonly PopCapability Expire; // = "EXPIRE"
public static readonly PopCapability Implementation; // = "IMPLEMENTATION"
public static readonly PopCapability Lang; // = "LANG"
public static readonly PopCapability LoginDelay; // = "LOGIN-DELAY"
public static readonly PopCapability Pipelining; // = "PIPELINING"
public static readonly PopCapability RespCodes; // = "RESP-CODES"
public static readonly PopCapability Sasl; // = "SASL"
public static readonly PopCapability Stls; // = "STLS"
public static readonly PopCapability Top; // = "TOP"
public static readonly PopCapability Uidl; // = "UIDL"
public static readonly PopCapability User; // = "USER"
public static readonly PopCapability Utf8; // = "UTF8"
public PopCapability(string tag, params string[] arguments) {}
public static IReadOnlyStringSet<PopCapability> AllCapabilities { get; }
public IReadOnlyList<string> Arguments { get; }
public string Tag { get; }
public override string Value { get; }
public bool ContainsAllArguments(IEnumerable<string> arguments) {}
public bool ContainsAllArguments(params string[] arguments) {}
public bool Equals(PopCapability other) {}
public override bool Equals(object obj) {}
public override int GetHashCode() {}
public static bool operator == (PopCapability x, PopCapability y) {}
public static bool operator != (PopCapability x, PopCapability y) {}
}
public static class PopCapabilitySetExtensions {
public static PopCapability FindByTag(this IReadOnlyStringSet<PopCapability> capabilities, PopCapability capability) {}
public static PopCapability FindByTag(this IReadOnlyStringSet<PopCapability> capabilities, string tag) {}
public static bool IsCapable(this IReadOnlyStringSet<PopCapability> capabilities, PopCapability requiredCapability) {}
- public static bool IsCapable(this IReadOnlyStringSet<PopCapability> capabilities, PopStringEnum feature) {}
+ public static bool IsCapable(this IReadOnlyStringSet<PopCapability> capabilities, PopEnumValue feature) {}
}
[Serializable]
public class PopConnectionException : PopException {
protected PopConnectionException(SerializationInfo info, StreamingContext context) {}
public PopConnectionException() {}
public PopConnectionException(string message) {}
public PopConnectionException(string message, Exception innerException) {}
}
public static class PopDefaultPorts {
public const int Pop = 110;
public const int Pops = 995;
}
[Serializable]
public class PopErrorResponseException : PopInvalidOperationException {
protected PopErrorResponseException(SerializationInfo info, StreamingContext context) {}
public PopErrorResponseException() {}
public PopErrorResponseException(PopCommandResult result) {}
public PopErrorResponseException(string message, PopCommandResult result) {}
public PopCommandResult Result { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public class PopIncapableException : PopInvalidOperationException {
protected PopIncapableException(SerializationInfo info, StreamingContext context) {}
public PopIncapableException() {}
public PopIncapableException(PopCapability requiredCapability) {}
public PopIncapableException(string message) {}
public PopIncapableException(string message, Exception innerException) {}
public PopIncapableException(string message, PopCapability requiredCapability) {}
public PopCapability RequiredCapability { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public abstract class PopInvalidOperationException : PopException {
protected PopInvalidOperationException() {}
protected PopInvalidOperationException(SerializationInfo info, StreamingContext context) {}
protected PopInvalidOperationException(string message) {}
protected PopInvalidOperationException(string message, Exception innerException) {}
}
[Serializable]
public class PopNoAppropriateAuthMechanismException : PopException {
protected PopNoAppropriateAuthMechanismException(SerializationInfo info, StreamingContext context) {}
public PopNoAppropriateAuthMechanismException() {}
public PopNoAppropriateAuthMechanismException(string message) {}
public PopNoAppropriateAuthMechanismException(string message, Exception innerException) {}
}
[Serializable]
public class PopProtocolViolationException : PopInvalidOperationException {
protected PopProtocolViolationException(SerializationInfo info, StreamingContext context) {}
public PopProtocolViolationException() {}
public PopProtocolViolationException(string message) {}
public PopProtocolViolationException(string message, Exception innerException) {}
}
[Serializable]
public sealed class PopResponseCode :
- PopStringEnum,
+ PopEnumValue,
IEquatable<PopResponseCode>
{
public static readonly PopResponseCode Auth; // = "AUTH"
public static readonly PopResponseCode InUse; // = "IN-USE"
public static readonly PopResponseCode LoginDelay; // = "LOGIN-DELAY"
public static readonly PopResponseCode SysPerm; // = "SYS/PERM"
public static readonly PopResponseCode SysTemp; // = "SYS/TEMP"
public static IReadOnlyStringSet<PopResponseCode> AllCodes { get; }
public bool Equals(PopResponseCode other) {}
public override bool Equals(object obj) {}
public override int GetHashCode() {}
public static bool operator == (PopResponseCode x, PopResponseCode y) {}
public static bool operator != (PopResponseCode x, PopResponseCode y) {}
}
[Serializable]
+ public class PopSecureConnectionException : PopUpgradeConnectionException {
+ protected PopSecureConnectionException(SerializationInfo info, StreamingContext context) {}
+ public PopSecureConnectionException() {}
+ public PopSecureConnectionException(string message) {}
+ public PopSecureConnectionException(string message, Exception innerException) {}
+ }
+
+ [Serializable]
public class PopUpgradeConnectionException : PopConnectionException {
protected PopUpgradeConnectionException(SerializationInfo info, StreamingContext context) {}
public PopUpgradeConnectionException() {}
public PopUpgradeConnectionException(string message) {}
public PopUpgradeConnectionException(string message, Exception innerException) {}
}
}
namespace Smdn.Net.Pop3.Protocol.DataStructures {
- public struct PopDropListing {
- public static readonly PopDropListing Empty; // = "{MessageCount=0, SizeInOctets=0}"
-
- public PopDropListing(long messageCount, long sizeInOctets) {}
+ public readonly struct PopDropListing {
+ public static readonly PopDropListing Empty; // = "{PopDropListing: MessageCount='0', SizeInOctets='0'}"
public long MessageCount { get; }
public long SizeInOctets { get; }
public override string ToString() {}
}
- public struct PopScanListing : IEquatable<long> {
- public static readonly PopScanListing Invalid; // = "{MessageNumber=0, SizeInOctets=0}"
-
- public PopScanListing(long messageNumber, long sizeInOctets) {}
+ public readonly struct PopScanListing : IEquatable<long> {
+ public static readonly PopScanListing Invalid; // = "{PopScanListing: MessageNumber='0', SizeInOctets='0'}"
public long MessageNumber { get; }
public long SizeInOctets { get; }
public bool Equals(long other) {}
public override string ToString() {}
}
- public struct PopUniqueIdListing :
+ public readonly struct PopUniqueIdListing :
IEquatable<long>,
IEquatable<string>
{
- public static readonly PopUniqueIdListing Invalid; // = "{MessageNumber=0, UniqueId=}"
-
- public PopUniqueIdListing(long messageNumber, string uniqueId) {}
+ public static readonly PopUniqueIdListing Invalid; // = "{PopUniqueIdListing: MessageNumber='0', UniqueId=(null)}"
public long MessageNumber { get; }
public string UniqueId { get; }
public bool Equals(long other) {}
public bool Equals(string other) {}
public override string ToString() {}
}
}
namespace Smdn.Net.Pop3.Protocol.Session {
public interface IPopSessionProfile {
bool AllowApopLogin { get; }
bool AllowInsecureLogin { get; }
bool AllowStandardLogin { get; }
Uri Authority { get; }
ICredentialsByHost Credentials { get; }
int ReceiveTimeout { get; }
int SendTimeout { get; }
int Timeout { get; }
bool UseTlsIfAvailable { get; }
IReadOnlyList<string> UsingSaslMechanisms { get; }
}
public enum PopSessionState : int {
Authorization = 1,
+ Disconnected = 4,
NotConnected = 0,
Transaction = 2,
Update = 3,
}
public sealed class PopSession :
IConnectionInfo,
IDisposable
{
- public PopSession(string host, int port = 110, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, UpgradeConnectionStreamCallback createAuthenticatedStream = null) {}
+ public PopSession() {}
+ public PopSession(string hostname, int port = -1, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, UpgradeConnectionStreamCallback createAuthenticatedStream = null) {}
public bool ApopAvailable { get; }
public Uri Authority { get; }
public bool HandlesIncapableAsException { get; set; }
- public bool IsDisposed { get; }
public bool IsSecureConnection { get; }
public bool IsTransactionProceeding { get; }
public int ReceiveTimeout { get; set; }
public int SendTimeout { get; set; }
public IReadOnlyStringSet<PopCapability> ServerCapabilities { get; }
string IConnectionInfo.Host { get; }
int IConnectionInfo.Port { get; }
public PopSessionState State { get; }
public string Timestamp { get; }
public int TransactionTimeout { get; set; }
public PopCommandResult Apop(ICredentialsByHost credentials, string username = null) {}
public PopCommandResult Auth(PopAuthenticationMechanism authenticationMechanism, ICredentialsByHost credentials, string username = null, CancellationToken cancellationToken = default) {}
public PopCommandResult Auth(SaslClientMechanism specificAuthenticationMechanism, CancellationToken cancellationToken = default) {}
public PopCommandResult Capa() {}
public PopCommandResult Capa(out IReadOnlyStringSet<PopCapability> capabilities) {}
+ public Task ConnectAsync(string hostname, int port = -1, ResolveHostAddressCallback resolveHostAddress = null, UpgradeConnectionStreamCallback createAuthenticatedStream = null, CancellationToken cancellationToken = default) {}
+ public static Task<PopSession> CreateAsync(IPopSessionProfile profile, SaslClientMechanism authMechanism = null, ResolveHostAddressCallback resolveHostAddress = null, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
public PopCommandResult Dele(long messageNumber) {}
public void Disconnect(bool logout = true) {}
+ public void Dispose() {}
public PopCommandResult GenericCommand(string command, bool isResponseMultiline, out IReadOnlyList<PopResponse> responses, params string[] arguments) {}
public PopCommandResult GenericCommand(string command, bool isResponseMultiline, params string[] arguments) {}
public PopCommandResult GenericCommand(string command, out IReadOnlyList<PopResponse> responses, params string[] arguments) {}
public PopCommandResult GenericCommand(string command, params string[] arguments) {}
public PopCommandResult List(long messageNumber, out PopScanListing scanListing) {}
public PopCommandResult ListAll(out List<PopScanListing> scanListings, int expectedResultCount = 0) {}
public PopCommandResult Login(ICredentialsByHost credentials, string username = null) {}
public PopCommandResult Login(string username, string password) {}
public PopCommandResult NoOp() {}
public PopCommandResult Pass(ICredentialsByHost credentials) {}
public PopCommandResult Pass(string password) {}
public PopCommandResult Quit() {}
public PopCommandResult Retr(long messageNumber, ref Stream messageStream) {}
public PopCommandResult Rset() {}
public PopCommandResult Stat(out PopDropListing dropListing) {}
public PopCommandResult Stls(UpgradeConnectionStreamCallback createAuthenticatedStream, bool reissueCapability = false) {}
- void IDisposable.Dispose() {}
public override string ToString() {}
public PopCommandResult Top(long messageNumber, int lines, ref Stream messageStream) {}
public PopCommandResult Uidl(long messageNumber, out PopUniqueIdListing uniqueIdListing) {}
public PopCommandResult UidlAll(out List<PopUniqueIdListing> uniqueIdListings, int expectedResultCount = 0) {}
public PopCommandResult User(ICredentialsByHost credentials) {}
public PopCommandResult User(string username) {}
}
-
- public static class PopSessionCreator {
- public static PopCommandResult CreateSession(out PopSession session, IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStream, CancellationToken cancellationToken = default) {}
- public static PopSession CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStream, CancellationToken cancellationToken = default) {}
- }
}
namespace Smdn.Net.Pop3.Protocol.Strings {
[Serializable]
- public abstract class PopStringEnum : IStringEnum {
- protected PopStringEnum(string @value) {}
-
+ public abstract class PopEnumValue : IEquatable<string> {
public virtual string Value { get; }
- public bool Equals(IStringEnum other) {}
+ public bool Equals(string other) {}
public override bool Equals(object obj) {}
- public virtual bool Equals(string other) {}
public override int GetHashCode() {}
public override string ToString() {}
}
}
namespace Smdn.Net.Pop3.Protocol.Transmission {
public interface IPopDataResponse {
ByteString Data { get; }
}
public enum PopStatusIndicator : int {
Negative = -1,
Positive = 1,
Undefined = 0,
}
public sealed class PopCommand {
public string Command { get; }
public IReadOnlyList<string> Parameters { get; }
public static PopCommand Create(string command, params string[] parameters) {}
public static PopCommand CreateCancelResponse() {}
public static PopCommand CreateContinuation(string parameter) {}
public override string ToString() {}
}
[Serializable]
public class PopCommandResult : ISerializable {
internal protected PopCommandResult(SerializationInfo info, StreamingContext context) {}
public string Description { get; }
public virtual bool IsConcludedByClientSide { get; }
public virtual bool IsSuccess { get; }
public IReadOnlyList<PopResponse> ReceivedResponses { get; }
public PopStatusResponse StatusResponse { get; }
public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
public PopStatusResponse GetResponseCode(PopResponseCode code) {}
public bool IsResponseStatus(PopStatusIndicator status) {}
public override string ToString() {}
}
public sealed class PopCommandSender {
public PopCommandSender(LineOrientedBufferedStream baseStream) {}
public void Send(PopCommand command) {}
}
public sealed class PopConnection : ConnectionBase {
- public PopConnection(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStream) {}
+ public PopConnection() {}
- public static TraceSource TraceSource { get; }
+ public static TraceSource ConnectionTraceSource { get; }
+ protected override TraceSource TraceSource { get; }
- protected override LineOrientedBufferedStream CreateBufferedStream(Stream stream) {}
- protected override Exception CreateConnectException(string message, Exception innerException) {}
- protected override Exception CreateUpgradeStreamException(string message, Exception innerException) {}
+ protected override Exception CreateConnectException(string message, Exception baseException) {}
+ protected override Exception CreateUpgradeConnectionException(string message, Exception baseException) {}
+ protected override Exception CreateUpgradeToSecureConnectionException(string message, Exception baseException) {}
+ protected override int GetDefaultPort(bool asSecurePortConnection) {}
+ protected override void OnConnectionStreamChanged(Stream stream) {}
public void SendCommand(PopCommand command) {}
public bool TryReceiveLine(Stream stream, out int receivedLineLength) {}
public PopResponse TryReceiveResponse() {}
}
[Serializable]
public sealed class PopContinuationRequest : PopResponse {
public ByteString Base64Text { get; }
public override string ToString() {}
}
[Serializable]
public sealed class PopFollowingResponse :
PopResponse,
IPopDataResponse
{
ByteString IPopDataResponse.Data { get; }
public ByteString Text { get; }
public override string ToString() {}
}
[Serializable]
public abstract class PopFormatException : FormatException {
protected PopFormatException() {}
protected PopFormatException(SerializationInfo info, StreamingContext context) {}
protected PopFormatException(string message) {}
protected PopFormatException(string message, Exception innerException) {}
}
[Serializable]
public class PopMalformedResponseException : PopFormatException {
protected PopMalformedResponseException(SerializationInfo info, StreamingContext context) {}
public PopMalformedResponseException() {}
public PopMalformedResponseException(string message) {}
public PopMalformedResponseException(string message, Exception innerException) {}
public PopMalformedResponseException(string message, string causedResponse) {}
public string CausedResponse { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public class PopMalformedTextException : PopFormatException {
protected PopMalformedTextException(SerializationInfo info, StreamingContext context) {}
public PopMalformedTextException() {}
public PopMalformedTextException(ByteString causedText) {}
public PopMalformedTextException(string message) {}
public PopMalformedTextException(string message, ByteString causedText) {}
public PopMalformedTextException(string message, Exception innerException) {}
public ByteString CausedText { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public abstract class PopResponse {
}
public static class PopResponseParser {
public static PopCapability FromCapa(PopFollowingResponse response) {}
public static string FromGreetingBanner(PopStatusResponse response) {}
public static PopScanListing FromList(PopFollowingResponse response) {}
public static PopScanListing FromList(PopStatusResponse response) {}
public static PopDropListing FromStat(PopStatusResponse response) {}
public static PopUniqueIdListing FromUidl(PopFollowingResponse response) {}
public static PopUniqueIdListing FromUidl(PopStatusResponse response) {}
}
public sealed class PopResponseReceiver {
public PopResponseReceiver(LineOrientedBufferedStream baseStream) {}
public bool HandleAsMultiline { get; set; }
public bool ReceiveLine(Stream stream, out int length) {}
public PopResponse ReceiveResponse() {}
}
[Serializable]
public sealed class PopResponseText {
public PopResponseCode Code { get; }
public ByteString Text { get; }
public string GetTextAsString() {}
public override string ToString() {}
}
[Serializable]
public sealed class PopStatusResponse :
PopResponse,
IPopDataResponse
{
public PopResponseText ResponseText { get; }
ByteString IPopDataResponse.Data { get; }
public PopStatusIndicator Status { get; }
public string Text { get; }
public override string ToString() {}
}
[Serializable]
public sealed class PopTerminationResponse : PopResponse {
public override string ToString() {}
}
public static class PopTextParser {
public static PopCapability ToCapability(ByteString[] texts) {}
public static PopDropListing ToDropListing(ByteString messageCount, ByteString sizeInOctets) {}
public static long ToMessageNumber(ByteString text) {}
public static long ToNumber(ByteString text) {}
public static PopScanListing ToScanListing(ByteString messageNumber, ByteString sizeInOctets) {}
public static string ToString(ByteString text) {}
public static PopUniqueIdListing ToUniqueIdListing(ByteString messageNumber, ByteString uniqueId) {}
}
}
namespace Smdn.Net.Pop3.Urls {
public class PopStyleUriParser : GenericUriParser {
public PopStyleUriParser() {}
protected static void CheckUriScheme(Uri uri) {}
public static PopAuthenticationMechanism GetAuthType(Uri uri) {}
public static string GetAuthority(Uri uri) {}
public static string GetStrongAuthority(Uri uri) {}
public static string GetUser(Uri uri) {}
protected override void InitializeAndValidate(Uri uri, out UriFormatException parsingError) {}
}
public static class PopUri {
public static readonly string UriSchemePop = "pop";
public static readonly string UriSchemePops = "pops";
public static int GetDefaultPortFromScheme(Uri uri) {}
public static int GetDefaultPortFromScheme(string scheme) {}
public static bool IsPop(Uri uri) {}
public static void RegisterParser() {}
}
public class PopUriBuilder :
ICloneable,
IEquatable<PopUriBuilder>,
IEquatable<Uri>
{
public PopUriBuilder() {}
public PopUriBuilder(Uri uri) {}
public PopUriBuilder(bool popsScheme, string host) {}
public PopUriBuilder(bool popsScheme, string host, int port) {}
public PopUriBuilder(bool popsScheme, string host, int port, string userName, PopAuthenticationMechanism authType) {}
public PopUriBuilder(bool popsScheme, string host, string userName, PopAuthenticationMechanism authType) {}
public PopUriBuilder(string host, int port) {}
public PopUriBuilder(string host, int port, string userName, PopAuthenticationMechanism authType) {}
public PopUriBuilder(string host, string userName, PopAuthenticationMechanism authType) {}
public PopUriBuilder(string uri) {}
public PopAuthenticationMechanism AuthType { get; set; }
public string Host { get; set; }
public int Port { get; set; }
public string Scheme { get; set; }
public Uri Uri { get; }
public string UserName { get; set; }
public PopUriBuilder Clone() {}
public bool Equals(PopUriBuilder other) {}
public bool Equals(Uri other) {}
public override bool Equals(object obj) {}
public override int GetHashCode() {}
object ICloneable.Clone() {}
public override string ToString() {}
}
}