1.91-netstandard2.0_vs_2.0alpha1-netstandard2.0.apilist.diff
--- Smdn.Net.MessageAccessProtocols-1.91-netstandard2.0.apilist.cs 2019-01-30 03:03:43.717867473 +0900
+++ Smdn.Net.MessageAccessProtocols-2.0alpha1-netstandard2.0.apilist.cs 2019-01-30 03:03:46.469822135 +0900
@@ -1,213 +1,219 @@
-// Smdn.Net.MessageAccessProtocols-1.91 (netstandard2.0)
+// Smdn.Net.MessageAccessProtocols-2.0alpha1 (netstandard2.0)
// Name: Smdn.Net.MessageAccessProtocols
// TargetFramework: .NETStandard,Version=v2.0
-// AssemblyVersion: 1.91.0.0
-// InformationalVersion: 1.91 (netstandard2.0)
+// AssemblyVersion: 2.0.0.0
+// InformationalVersion: 2.0alpha1 (netstandard2.0)
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using Smdn.IO.Streams.LineOriented;
using Smdn.Net.Connection;
using Smdn.Net.MessageAccessProtocols;
using Smdn.Net.MessageAccessProtocols.Diagnostics;
namespace Smdn.IO.Streams {
public class InterruptStream : Stream {
public InterruptStream(Stream innerStream) {}
public override bool CanRead { get; }
public override bool CanSeek { get; }
public override bool CanTimeout { get; }
public override bool CanWrite { get; }
public Stream InnerStream { get; }
public override long Length { get; }
public override long Position { get; set; }
public override void Close() {}
public override void Flush() {}
- protected virtual int OnRead(byte[] dest, int offset, int count) {}
- protected virtual void OnReading(byte[] dest, int offset, int count, out bool abortRead) {}
- protected virtual void OnWriting(byte[] src, int offset, int count, out bool abortWrite) {}
- protected virtual void OnWritten(byte[] src, int offset, int count) {}
- public override int Read(byte[] dest, int offset, int count) {}
+ protected virtual int OnRead(byte[] buffer, int offset, int count) {}
+ protected virtual void OnReading(byte[] buffer, int offset, int count, out bool abortRead) {}
+ protected virtual void OnWriting(byte[] buffer, int offset, int count, out bool abortWrite) {}
+ protected virtual void OnWritten(byte[] buffer, int offset, int count) {}
+ public override int Read(byte[] buffer, int offset, int count) {}
public override long Seek(long offset, SeekOrigin origin) {}
public override void SetLength(long @value) {}
- public override void Write(byte[] src, int offset, int count) {}
+ public override void Write(byte[] buffer, int offset, int count) {}
}
}
namespace Smdn.IO.Streams.LineOriented {
public sealed class LineOrientedBufferedStream : StrictLineOrientedStream {
public LineOrientedBufferedStream(Stream stream) {}
public override bool CanSeek { get; }
public override long Length { get; }
public override long Position { get; set; }
protected override void Dispose(bool disposing) {}
public override void Flush() {}
public override long Seek(long offset, SeekOrigin origin) {}
public override void SetLength(long @value) {}
public override void Write(byte[] src, int offset, int count) {}
public void Write(Stream sourceStream) {}
public void WriteToCrLf(byte[] src) {}
}
}
namespace Smdn.Net {
public static class ICredentialsByHostExtensions {
- public static NetworkCredential LookupCredential(this ICredentialsByHost credentials, ConnectionBase connection, string username, IStringEnum authenticationMechanism) {}
+ public static NetworkCredential LookupCredential(this ICredentialsByHost credentials, IConnectionInfo connection, string username, IStringEnum authenticationMechanism) {}
public static NetworkCredential LookupCredential(this ICredentialsByHost credentials, string host, int port, string username, string authenticationMechanism) {}
}
}
namespace Smdn.Net.Connection {
public delegate Stream UpgradeConnectionStreamCallback(ConnectionBase connection, Stream baseStream);
public interface IConnectionInfo {
string Host { get; }
- bool IsClosed { get; }
- bool IsSecureConnection { get; }
- bool IsSecurePortConnection { get; }
- IPEndPoint LocalEndPoint { get; }
int Port { get; }
- IPEndPoint RemoteEndPoint { get; }
}
public abstract class ConnectionBase :
IConnectionInfo,
IDisposable
{
protected ConnectionBase(TraceSource traceSource) {}
public string Host { get; }
public int Id { get; }
- public bool IsClosed { get; }
+ public bool IsConnected { get; }
public bool IsSecureConnection { get; protected set; }
- public bool IsSecurePortConnection { get; protected set; }
+ public bool IsSecurePortConnection { get; }
public IPEndPoint LocalEndPoint { get; }
public int Port { get; }
protected virtual Stream RawStream { get; }
public int ReceiveTimeout { get; set; }
public IPEndPoint RemoteEndPoint { get; }
public int SendTimeout { get; set; }
protected Socket Socket { get; }
public static SslProtocols SslProtocolsDefault { get; }
protected LineOrientedBufferedStream Stream { get; }
protected void CheckConnected() {}
public void Close() {}
- protected virtual void Connect(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStreamCallback) {}
+ protected virtual void Connect(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStream) {}
protected virtual LineOrientedBufferedStream CreateBufferedStream(Stream stream) {}
public static Stream CreateClientSslStream(ConnectionBase connection, Stream baseStream, X509Certificate2Collection clientCertificates, SslProtocols enabledSslProtocols, RemoteCertificateValidationCallback serverCertificateValidationCallback, LocalCertificateSelectionCallback clientCertificateSelectionCallback) {}
protected abstract Exception CreateConnectException(string message, Exception innerException);
protected abstract Exception CreateUpgradeStreamException(string message, Exception innerException);
protected virtual void Dispose(bool disposing) {}
~ConnectionBase() {}
void IDisposable.Dispose() {}
public override string ToString() {}
- public virtual void UpgradeStream(UpgradeConnectionStreamCallback upgradeStreamCallback) {}
+ public virtual void UpgradeStream(UpgradeConnectionStreamCallback upgradeStream) {}
}
}
namespace Smdn.Net.MessageAccessProtocols {
+ public interface IReadOnlyStringSet<TStringEnum> : IReadOnlyCollection<TStringEnum> where TStringEnum : IStringEnum {
+ bool Contains(TStringEnum item);
+ bool Contains(string item);
+ bool IsProperSubsetOf(IEnumerable<TStringEnum> other);
+ bool IsProperSupersetOf(IEnumerable<TStringEnum> other);
+ bool IsSubsetOf(IEnumerable<TStringEnum> other);
+ bool IsSupersetOf(IEnumerable<TStringEnum> other);
+ bool Overlaps(IEnumerable<TStringEnum> other);
+ bool SetEquals(IEnumerable<TStringEnum> other);
+ bool TryGetValue(string @value, out TStringEnum item);
+ }
+
public interface IStringEnum :
IEquatable<IStringEnum>,
IEquatable<string>
{
string Value { get; }
}
public class StringEnumSet<TStringEnum> :
- IReadOnlyCollection<TStringEnum>,
+ IReadOnlyStringSet<TStringEnum>,
ISet<TStringEnum>
where TStringEnum : class, IStringEnum
{
public StringEnumSet() {}
public StringEnumSet(IEnumerable<TStringEnum> items) {}
public StringEnumSet(IEnumerable<TStringEnum> items, IEqualityComparer<string> comparer) {}
public StringEnumSet(bool isReadOnly) {}
public StringEnumSet(bool isReadOnly, IEnumerable<TStringEnum> items, IEqualityComparer<string> comparer) {}
public StringEnumSet(bool isReadOnly, IEqualityComparer<string> comparer) {}
public int Count { get; }
public bool IsReadOnly { get; }
public bool Add(TStringEnum item) {}
public void AddRange(IEnumerable<TStringEnum> items) {}
public void Clear() {}
public bool Contains(TStringEnum item) {}
public bool Contains(string @value) {}
public void CopyTo(TStringEnum[] array, int arrayIndex) {}
public void ExceptWith(IEnumerable<TStringEnum> other) {}
- public TStringEnum Find(string @value) {}
public IEnumerator<TStringEnum> GetEnumerator() {}
public void IntersectWith(IEnumerable<TStringEnum> other) {}
public bool IsProperSubsetOf(IEnumerable<TStringEnum> other) {}
public bool IsProperSupersetOf(IEnumerable<TStringEnum> other) {}
public bool IsSubsetOf(IEnumerable<TStringEnum> other) {}
public bool IsSupersetOf(IEnumerable<TStringEnum> other) {}
public bool Overlaps(IEnumerable<TStringEnum> other) {}
public bool Remove(TStringEnum item) {}
public int RemoveWhere(Predicate<TStringEnum> match) {}
public bool SetEquals(IEnumerable<TStringEnum> other) {}
public void SymmetricExceptWith(IEnumerable<TStringEnum> other) {}
void ICollection<TStringEnum>.Add(TStringEnum item) {}
IEnumerator IEnumerable.GetEnumerator() {}
public TStringEnum[] ToArray() {}
public override string ToString() {}
public string[] ToStringArray() {}
- public bool TryGet(string @value, out TStringEnum item) {}
+ public bool TryGetValue(string @value, out TStringEnum item) {}
public void UnionWith(IEnumerable<TStringEnum> other) {}
}
public static class StringEnumUtils {
public static IEnumerable<TStringEnum> GetDefinedConstants<TStringEnum>() where TStringEnum : class, IStringEnum {}
}
}
namespace Smdn.Net.MessageAccessProtocols.Diagnostics {
public sealed class ExceptionTraceData : TraceDataBase {
public Exception Exception { get; }
public override string ToString() {}
}
public sealed class MessageTraceData : TraceDataBase {
public string Message { get; }
public override string ToString() {}
}
public sealed class ReceiveTraceData : TraceDataBase {
public ArraySegment<byte> Data { get; }
public IPEndPoint LocalEndPoint { get; }
public IPEndPoint RemoteEndPoint { get; }
public override string ToString() {}
}
public sealed class SendTraceData : TraceDataBase {
public ArraySegment<byte> Data { get; }
public IPEndPoint LocalEndPoint { get; }
public IPEndPoint RemoteEndPoint { get; }
public override string ToString() {}
}
public abstract class TraceDataBase {
internal protected TraceDataBase(int connectionId) {}
public int ConnectionId { get; }
public DateTime DateTime { get; }
}
}