/// <summary>
/// Determines whether an object is structurally equal to the current instance.
/// </summary>
/// <param name="other">The object to compare with the current instance.</param>
/// <param name="comparer">An object that determines whether the current instance and other are equal.</param>
/// <returns>true if the two objects are equal; otherwise, false.</returns>
bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
var self = this;
Array otherArray = other as Array;
if (otherArray == null)
{
var theirs = other as IImmutableArray;
if (theirs != null)
{
otherArray = theirs.Array;
if (self.array == null && otherArray == null)
{
return(true);
}
else if (self.array == null)
{
return(false);
}
}
}
IStructuralEquatable ours = self.array;
return(ours.Equals(otherArray, comparer));
}
/// <inheritdoc />
public new bool Equals(object x, object y)
{
if (x == null && y == null)
{
return(true);
}
if (x == null || y == null)
{
return(false);
}
// if there is a comparer registered for the type then use that
IEqualityComparer comparer;
if (this.comparerPerType.TryGetValue(x.GetType(), out comparer))
{
return(comparer.Equals(x, y));
}
// check if the type is structurally equatable, and if so pass this comparer as the structural comparer
IStructuralEquatable structuralEquatable = x as IStructuralEquatable;
if (structuralEquatable != null)
{
return(structuralEquatable.Equals(y, this));
}
// otherwise fall back on regular equality
return(x.Equals(y));
}
public void IStructuralEquatable_Equals_NullComparer_ThrowsNullReferenceException()
{
// This was not fixed in order to be compatible with the full .NET framework and Xamarin. See #13410
IStructuralEquatable equatable = (IStructuralEquatable)Tuple;
Assert.Throws <NullReferenceException>(() => equatable.Equals(Tuple, null));
}
public bool WriteToPLC(int startingAddress, int[] values)
{
if (!client.Connected)
{
try
{
//client.ConnectionTimeout = 5000;
//client.Connect();
Connect();
}
catch (Exception ex)
{
log.Error($"PLC Connecion ex: {ex}");
//Thread.Sleep(100);
//client.Disconnect();
//client.Connect();
}
}
//yazdı
client.WriteMultipleRegisters(startingAddress, values);
//yazdıklarını okudu
var arr = client.ReadHoldingRegisters(startingAddress, values.Length);
//ikisini karşılaştırdı doğru yazıp yazmadığını kontrol etti
IStructuralEquatable se1 = values;
bool isEqual = se1.Equals(arr, StructuralComparisons.StructuralEqualityComparer);
client.Disconnect();
return(isEqual);
}
public ImageInfoGet GetImage(string fileName, string mas)
{
ImageInfoGet tmp = new ImageInfoGet();
tmp.Path = fileName;
tmp.JpegCover = mas;
db = new Database.ApplicationContext();
foreach (var img in db.Images)
{
if (fileName == img.Path)
{
var mas1 = Convert.FromBase64String(mas);
IStructuralEquatable equ = mas1;
var masFromDB = img.Details.Image;
if (equ.Equals(masFromDB, EqualityComparer <object> .Default))
{
img.count++;
db.SaveChanges();
tmp.Name = img.Name;
tmp.Class = img.ClassName;
tmp.Confidence = img.Confidence;
return(tmp);
}
}
}
return(null);
}
public static bool ArraysEqual(Array a, Array b)
{
IStructuralEquatable se1 = a;
//Next returns True
return(se1.Equals(b, StructuralComparisons.StructuralEqualityComparer));
}
public static bool HeaderValidation(string[] header, string[] expectedHeader, string resourceType)
{
bool correctHeader = false;
IStructuralEquatable actualHeader = header;
if (actualHeader.Equals(expectedHeader, StructuralComparisons.StructuralEqualityComparer))
{
correctHeader = true;
}
else
{
string column = string.Empty;
for (var iterator = 0; iterator < expectedHeader.Length; iterator++)
{
if (!(header[iterator] == expectedHeader[iterator]))
{
column = expectedHeader[iterator];
break;
}
}
dynamic logHeader = null;
int count = 0;
foreach (var item in expectedHeader)
{
logHeader = logHeader + item;
if (count < expectedHeader.Count() - 1)
{
logHeader = logHeader + ", ";
count++;
}
}
throw new Exception("Header Mismatch for " + resourceType + " at column " + column + "\n" + "Expected header:" + "\n" + logHeader);
}
return(correctHeader);
}
static void Main()
{
int[] array1 = { 1, 2, 3 };
int[] array2 = { 1, 2, 3 };
IStructuralEquatable structuralEquator = array1;
Console.WriteLine(array1.Equals(array2)); // False
Console.WriteLine(structuralEquator.Equals(array2, EqualityComparer <int> .Default)); // True
// string arrays
string[] a1 = "a b c d e f g".Split();
string[] a2 = "A B C D E F G".Split();
IStructuralEquatable structuralEquator1 = a1;
bool areEqual = structuralEquator1.Equals(a2, StringComparer.InvariantCultureIgnoreCase);
Console.WriteLine("Arrays of strings are equal:" + areEqual);
//tuples
var firstTuple = Tuple.Create(1, "aaaaa");
var secondTuple = Tuple.Create(1, "AAAAA");
IStructuralEquatable structuralEquator2 = firstTuple;
bool areTuplesEqual = structuralEquator2.Equals(secondTuple, StringComparer.InvariantCultureIgnoreCase);
Console.WriteLine("Are tuples equal:" + areTuplesEqual);
IStructuralComparable sc1 = firstTuple;
int comparisonResult = sc1.CompareTo(secondTuple, StringComparer.InvariantCultureIgnoreCase);
Console.WriteLine("Tuples comarison result:" + comparisonResult); //0
}
public static void Main()
{
Tuple <string, double, int>[] scores =
{ Tuple.Create("Ed", 78.8, 8),
Tuple.Create("Abbey", 92.1, 9),
Tuple.Create("Jim", 71.2, 9),
Tuple.Create("Sam", 91.7, 8),
Tuple.Create("Sandy", 71.2, 5),
Tuple.Create("Penelope", 82.9, 8),
Tuple.Create("Serena", 71.2, 9),
Tuple.Create("Judith", 84.3, 9) };
for (int ctr = 0; ctr < scores.Length; ctr++)
{
IStructuralEquatable score = scores[ctr];
for (int ctr2 = ctr + 1; ctr2 < scores.Length; ctr2++)
{
Console.WriteLine("{0} = {1}: {2}", score,
scores[ctr2],
score.Equals(scores[ctr2],
new Item2Comparer <string, double, int>()));
}
Console.WriteLine();
}
}
public void Sort_ArrayAndDescSumElementsComparer_ArraySortedByMaxAbsolutValueByDesc()
{
int[][] array = new int[][]
{
new int[] { -1, 2 },
new int[] { 0, 1, 1, 0 },
new int[] { 0, 0, 0, 0 },
new int[] { 3, -5, 2, 3 },
new int[] { 2, 4, 1 }
};
int[][] expected = new int[][]
{
new int[] { 2, 4, 1 },
new int[] { 3, -5, 2, 3 },
new int[] { 0, 1, 1, 0 },
new int[] { -1, 2 },
new int[] { 0, 0, 0, 0 }
};
JaggedArray.Sort(array, new DescSumElementsComparer());
IStructuralEquatable actual = array;
Assert.IsTrue(actual.Equals(expected, StructuralComparisons.StructuralEqualityComparer));
}
private void buttonLogin_Click(object sender, EventArgs e)
{
AES256 AES = new AES256();
string hashString = null; byte[] encryptedBytes = null;
// 암호화 기본 설정
AES.KeyString = textBoxKey.Text;
AES.SaltBytes = CommonData.EncryptSalt;
// 비밀번호 암호화
hashString = Convert.ToBase64String(SHA512.Create().ComputeHash(Encoding.UTF8.GetBytes(CommonData.HashSalt + textBoxPassword.Text)));
encryptedBytes = AES.EncryptByte(Encoding.UTF8.GetBytes(hashString + textBoxPassword.Text));
// 정보 로드 및 배열 비교 준비
byte[] loadData = File.ReadAllBytes(Path.Combine(Application.StartupPath, CommonData.Folder, CommonData.PasswordFile));
IStructuralEquatable SE = loadData;
// 배열 서로 비교
if (SE.Equals(encryptedBytes, StructuralComparisons.StructuralEqualityComparer))
{
frmMain form = new frmMain();
form.Show(); this.Hide();
}
else
{
MessageBox.Show("로그인에 실패하였습니다.", "오류", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
Application.Exit();
}
}
public new bool Equals(Object x, Object y)
{
if (x != null)
{
IStructuralEquatable seObj = x as IStructuralEquatable;
if (seObj != null)
{
return(seObj.Equals(y, this));
}
if (y != null)
{
return(x.Equals(y));
}
else
{
return(false);
}
}
if (y != null)
{
return(false);
}
return(true);
}
public static void Show()
{
{
int[] a1 = { 1, 2, 3 };
int[] a2 = { 1, 2, 3 };
IStructuralEquatable se1 = a1;
Console.WriteLine(a1.Equals(a2)); // False
Console.WriteLine(se1.Equals(a2, EqualityComparer <int> .Default)); // True
}
{
string[] a1 = "the quick brown fox".Split();
string[] a2 = "THE QUICK BROWN FOX".Split();
IStructuralEquatable se1 = a1;
bool isTrue = se1.Equals(a2, StringComparer.InvariantCultureIgnoreCase);
}
{
var t1 = Tuple.Create(1, "foo");
var t2 = Tuple.Create(1, "FOO");
IStructuralEquatable se1 = t1;
Console.WriteLine(se1.Equals(t2, StringComparer.InvariantCultureIgnoreCase)); // True
IStructuralComparable sc1 = t1;
Console.WriteLine(sc1.CompareTo(t2, StringComparer.InvariantCultureIgnoreCase)); // 0
}
{
var t1 = Tuple.Create(1, "FOO");
var t2 = Tuple.Create(1, "FOO");
Console.WriteLine(t1.Equals(t2)); // True
}
}
private bool CheckSd()
{
IStructuralEquatable left = Left.ToByteArray();
if (left.Equals(Right.ToByteArray(), EqualityComparer <byte> .Default))
{
return(true);
}
if (!Report)
{
return(false);
}
if (Left.Control != Right.Control)
{
WriteWarning($"Control mismatch, left {Left.Control} right {Right.Control}");
}
if (Left.RmControl != Right.RmControl)
{
WriteWarning($"RmControl mismatch, left {Left.RmControl} right {Right.RmControl}");
}
CompareSid("Owner", Left.Owner?.Sid, Right.Owner?.Sid);
CompareSid("Group", Left.Group?.Sid, Right.Group?.Sid);
CompareAcls("DACL", Left.Dacl, Right.Dacl);
CompareAcls("SACL", Left.Sacl, Right.Sacl);
return(false);
}
public bool Equals(WampMessage <TMessage> x, WampMessage <TMessage> y)
{
IStructuralEquatable xArguments = x.Arguments;
IStructuralEquatable yArguments = y.Arguments;
return(x.MessageType == y.MessageType &&
xArguments.Equals(yArguments, mRawComparer));
}
public static void Equals_WithNullComparer()
{
// Arrange
IStructuralEquatable one = One;
// Act & Assert
Assert.ThrowsAnexn("comparer", () => one.Equals(One, null !));
}
public static void Equals_None_ForReferenceT()
{
// Arrange
IStructuralEquatable none = Maybe <AnyT> .None;
var same = Maybe <AnyT> .None;
var some = Maybe.SomeOrNone(AnyT.Value);
var cmp = EqualityComparer <AnyT> .Default;
// Act & Assert
Assert.False(none.Equals(null, cmp));
Assert.False(none.Equals(new object(), cmp));
Assert.True(none.Equals(none, cmp));
Assert.True(none.Equals(same, cmp));
Assert.False(none.Equals(some, cmp));
}
public void IStructuralEquatable_Equals_NullComparer_ThrowsNullReferenceException()
{
// This was not fixed in order to be compatible with the .NET Framework and Xamarin.
// See https://github.com/dotnet/runtime/issues/19265
IStructuralEquatable equatable = (IStructuralEquatable)Tuple;
Assert.Throws <NullReferenceException>(() => equatable.Equals(Tuple, null));
}
static void Main(string[] args)
{
IContainer container = Container.SingleInstance;
//var container = new Container();
container.RegisterType <IEntityBase, StudentClass>();
//container.RegisterType(action =>
//{
// action.RegisterType<IEntityBase, StudentClass>();
//});
IEntityBase aa = container.Resolve <IEntityBase>();
IEntityBase bb = container.Resolve <IEntityBase>();
if (aa == bb)
{
}
if (aa.Equals(bb))
{
}
Console.WriteLine("Hello World!");
//IUnityContainer container = new UnityContainer();
//container.RegisterType<IEntityBase, Student>();
//container.RegisterType<IEntityBase, StudentClass>("adasd");
//container.RegisterType<IEntityBase, StudentClass>("1212");
//var student = container.Resolve<IEntityBase>("adasd");
//IEntityBase studentclass = container.Resolve<IEntityBase>("1212");
string[] a1 = "the quick brown fox".Split();
string[] a2 = "THE QUICK BROWN FOX".Split();
IStructuralEquatable se1 = a1;
bool isTrue = se1.Equals(a2, StringComparer.InvariantCultureIgnoreCase);
string s = "1212";
dynamic sb = s;
var sb1 = s;
Test1(s, sb1);
IEntityBase entityBase = new Student();
Queue queue = new Queue();
OrderedDictionary dictionary = new OrderedDictionary();
Stack stack = new Stack();
//IContainer container = new Container();
//container.RegisterType<IEntityBase, Student>();
//container.RegisterType<IEntityBase, StudentClass>();
////container.RegisterType<IEntityBase, StudentClass>();
//IEntityBase student = container.Resolve<IEntityBase>();
//var studentclass = container.Resolve<StudentClass>();
}
public void TestSum()
{
int[][] start = new[] { new[] { 1 }, null, null, new[] { -2, 7, 5 }, null, new[] { 40, 2 } };
int[][] result = new[] { null, null, null, new[] { 1 }, new[] { -2, 7, 5 }, new[] { 40, 2 } };
DelegateToInterfaceSort.SortBy(start, new ComparatorByMaxElement().Compare);
IStructuralEquatable eq = start;
Assert.AreEqual(eq.Equals(result, StructuralComparisons.StructuralEqualityComparer), true);
}
public void Stack_CopyTo_Test(int[] expectedResult)
{
int[] intArray = new int[5];
intArray[0] = 11;
intArray[1] = 12;
stack.CopyTo(intArray, 2);
IStructuralEquatable comparer = intArray;
Assert.IsTrue(comparer.Equals(expectedResult, EqualityComparer <int> .Default));
}
public void Queue_CopyTo_Test(string[] expectedResult)
{
string[] strArray = new string[5];
strArray[0] = "initial 1";
strArray[1] = "initial 2";
queue.CopyTo(strArray, 2);
IStructuralEquatable comparer = strArray;
Assert.IsTrue(comparer.Equals(expectedResult, EqualityComparer <string> .Default));
}
public static void Main()
{
var value1 = GetValues(1);
var value2 = GetValues(2);
IStructuralEquatable iValue1 = value1;
Console.WriteLine("{0} =\n{1} :\n{2}", value1, value2,
iValue1.Equals(value2,
new DoubleComparer <int, double, double, double, double>(.01)));
}
static void Main(string[] args)
{
int[] a1 = { 1, 2, 3 };
int[] a2 = { 1, 2, 3 };
IStructuralEquatable se1 = a1;
Console.WriteLine(a1.Equals(a2));
Console.WriteLine(se1.Equals(a2, EqualityComparer <int> .Default));
Console.ReadKey();
}
public void SortTests(int[] array)
{
int[] arraySystem = new int[array.Length];
Array.Copy(array, arraySystem, array.Length);
Array.Sort(arraySystem);
ArrayExtension.Sort(array);
IStructuralEquatable iArray = arraySystem;
Assert.IsTrue(iArray.Equals(array, StructuralComparisons.StructuralEqualityComparer));
}
public bool is_DATA(UInt16 bloc, byte[] trame)
{
byte[] a = op_data.Concat(BitConverter.GetBytes(bloc).Reverse()).ToArray();
IStructuralEquatable se1 = a;
if (se1.Equals(trame.Take(4).ToArray(), StructuralComparisons.StructuralEqualityComparer))
{
return(true);
}
return(false);
}
public static bool StructuralEqual(IStructuralEquatable left, IStructuralEquatable right)
{
if (left != null && right != null)
{
return(left.Equals(right, DefaultComparer));
}
else
{
return(left == null && right == null);
}
}
public bool Autenticar(string Usuario, string ClaveUsuario)
{
bool resultado = false;
try
{
ObjConnection = new SqlConnection(_ConexionData);
SqlCommand ObjCommand = new SqlCommand("SP_TBC_USUARIO_GetByAll", ObjConnection);
ObjParam = new SqlParameter();
ObjCommand.CommandType = CommandType.StoredProcedure;
ObjCommand.Parameters.AddWithValue("@ID", Usuario);
ObjCommand.Parameters.AddWithValue("@DS_NOMBRE_USUARIO", "");
ObjCommand.Parameters.AddWithValue("@CD_CLAVE_USUARIO", "");
ObjCommand.Parameters.AddWithValue("@ID_PERFIL_USUARIO", "");
ObjCommand.Parameters.AddWithValue("@DS_DIRE_EMAIL", "");
ObjCommand.Parameters.AddWithValue("@CD_ESTADO_USUARIO", 0);
ObjCommand.Parameters.AddWithValue("@OPCI_CONS", 1);
ObjConnection.Open();
SqlDataReader objReader = ObjCommand.ExecuteReader();
CEncriptacion objEncripcion = new CEncriptacion();
byte[] ClaveEncriptada;
byte[] ClaveEncriptadaGuardada;
while (objReader.Read())
{
ClaveEncriptadaGuardada = ((byte[])objReader["CD_CLAVE_USUARIO"]);
ClaveEncriptada = objEncripcion.Encrypt(CEncriptacion.ToBase64(ClaveUsuario));
IStructuralEquatable ob1 = ClaveEncriptadaGuardada;
if (ob1.Equals(ClaveEncriptada, StructuralComparisons.StructuralEqualityComparer))
{
resultado = true;
}
}
ObjConnection.Close();
if (ObjConnection.State != ConnectionState.Closed)
{
ObjConnection.Close();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(resultado);
}
public static void Main()
{
var rate1 = Tuple.Create("New York", -.013934, .014505,
-.1042733, .0354833, .093644, .0290792);
var rate2 = Tuple.Create("Unknown City", -.013934, .014505,
-.1042733, .0354833, .093644, .0290792);
var rate3 = Tuple.Create("Unknown City", -.013934, .014505,
-.1042733, .0354833, .093644, .029079);
var rate4 = Tuple.Create("San Francisco", -.0451934, -.0332858,
-.0512803, .0662544, .0728964, .0491912);
IStructuralEquatable eq = rate1;
// Compare first tuple with remaining two tuples.
Console.WriteLine("{0} = ", rate1.ToString());
Console.WriteLine(" {0} : {1}", rate2,
eq.Equals(rate2, new RateComparer <string, double, double, double, double, double, double>()));
Console.WriteLine(" {0} : {1}", rate3,
eq.Equals(rate3, new RateComparer <string, double, double, double, double, double, double>()));
Console.WriteLine(" {0} : {1}", rate4,
eq.Equals(rate4, new RateComparer <string, double, double, double, double, double, double>()));
}
private static bool LocalSettingFileIsOriginal()
{
if (ComputerFingerprint == null)
{
ComputerFingerprint = Fingerprint.Value;
Update();
return(true);
}
IStructuralEquatable eqa1 = ComputerFingerprint;
return(eqa1.Equals(Fingerprint.Value, StructuralComparisons.StructuralEqualityComparer));
}
