小编Bha*_*kar的帖子

为什么XOR仅用于加密算法,而其他逻辑门如OR,AND和NOR则不使用？

我见过开发人员使用下面的代码.它们之间的确切区别是什么,哪些符合标准？他们是一样的,Action而且Func<T>是一个代表,以及:

public event Action<EmployeeEventAgs> OnLeave;
public void Leave()
{
    OnLeave(new EmployeeEventAgs(this.ID));
}

VS

public delegate void GoOnLeave(EmployeeEventAgs e);
public event GoOnLeave OnLeave;
public void Leave()
{
    OnLeave(new EmployeeEventAgs(this.ID));
}

可能重复:
动态(C#4)和var之间有什么区别？

.NET 4.0(VS 2010)中dynamic和var关键字的区别是什么.根据MSDN,动态定义是 - 动态查找允许您编写方法,操作符和索引器调用,属性和字段访问,甚至是绕过C#的常规静态绑定的对象调用,而是动态解析.

var的定义是 - 隐式类型的局部变量是强类型的,就像你自己声明了类型一样,但编译器确定了类型.

这在下面的代码上下文中有何不同:

var a1 = new A();
a1.Foo(1);

dynamic a2 = new A();
a2.Foo(1);

如果我们序列化静态类会发生什么？如果我们序列化它,可以创建多个静态类的实例吗？

[Serializable]
public static class MyClass
{
    public static MyClass()
    {

    }

    public static bool IsTrue()
    {
       return true;
    }
}

假设我将对象XmlSerialize为XML文件,稍后我反序列化回一个对象.另一个副本存在于内存中(当somone第一次直观地表达静态calss时创建).请问,有两个副本的对象？如果是的话,我们可以阻止吗？它是否适用于遵循单例模式的任何类？

我们可以根据预定义的模式(即XSD或DTD)验证传入的XML文件,我们是否可以对传入的JSON对象进行验证.是否有可用的JSON模式定义？

我一直在对Random类进行一些测试,我使用了以下代码:

while (x++ <= 5000000)
{
    y = rnd.Next(1, 5000000);
    if (!data.Contains(y))
        data.Add(y);
    else
    {
        Console.WriteLine("Cycle {2}: Repetation found for number {0} after {1} iteration", y, x, i);
        break;
    }
}

我一直在改变rnd max limit(即5000000),我改变了迭代次数,得到了以下结果:

1) if y = rnd.Next(1, 5000) : The average is between 80 to 110 iterations
2) if y = rnd.Next(1, 5000000) : The average is between 2000 to 4000 iterations
3) if y = rnd.Next(1, int.MaxValue) : The average is between 40,000 to 80,000 iterations.

为什么我得到这些平均值,即我检查每个值的10次,80%的时间都在这个平均范围内.我不认为我们可以把它称为随机. …

这是一种普遍的看法,即反思很慢,并试图尽可能地避免它.但在目前的情况下,这种信念是否属实？当前的.net版本有很多变化,比如使用IL Weaving(即IL Emit)等,而不是传统的PropertyInfo和MethodInfo执行反射的方式.

这是否有任何令人信服的证据,新的反映不再那么慢,而且可以使用.是否有更好的方法来读取属性数据？

谢谢,巴斯卡

Dotfuscator如何工作？我试着对我的一些类进行模糊处理,并将方法/类重命名为a,b,c等.但是我仍然能看到这些方法中的代码？是这样,我做错了什么？

有什么东西可以防止完全阻止我的装配拆卸吗？

我正在使用RijndaelManaged来创建一个简单的加密/解密实用程序.这工作正常,但我试图将它与在Unix(Oracle)中创建的另一个程序集成.我的问题是,对于所有较小的输入字符串,我得到与Unix代码生成完全相同的加密十六进制,但对于更长的字符串,我的加密十六进制的一半是相同的,但另一半是不同的:

Unix输出:

012345678901234 - 00984BBED076541E051A239C02D97117 
0123456789012345678 - A0ACE158AD8CF70CEAE8F76AA27F62A30EA409ECE2F7FF84F1A9AF50817FC0C4

Windows输出(我的代码):

012345678901234 - 00984BBED076541E051A239C02D97117 (same as above)
0123456789012345678 - A0ACE158AD8CF70CEAE8F76AA27F62A3D9A1B396A614DA2C1281AA1F48BC3EBB (half exactly same as above)

我的Windows代码是:

public string Encrypt(byte[] PlainTextBytes, byte[] KeyBytes, string InitialVector)
        {
            byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(InitialVector);
            RijndaelManaged SymmetricKey = new RijndaelManaged();
            SymmetricKey.Mode = CipherMode.ECB;
            SymmetricKey.Padding = PaddingMode.PKCS7;
            ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(KeyBytes, InitialVectorBytes);
            MemoryStream MemStream = new MemoryStream();
            CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write);
            CryptoStream.Write(PlainTextBytes, 0, PlainTextBytes.Length);
            CryptoStream.FlushFinalBlock();
            byte[] CipherTextBytes = MemStream.ToArray();
            MemStream.Close();
            CryptoStream.Close();
            return ByteToHexConversion(CipherTextBytes);
        }

Unix(PL/SQL)代码:

FUNCTION …

Primality Check可能是数学中"那些"难题之一.所以,什么是最好和最快的算法可用于检查大量的素数.最粗糙和最慢的方式可能是:

public static bool IsPrime(int i)
{
    for (var x = 2; x < i - 1; i++)
    {
         if (i % x == 0)
         {
             return false;
         }
    }
    return true;
}

最近我读到使用网格计算阵列使用暴力破解了768位RSA算法.他们如何在巨大的素数上执行蛮力？每个处理单元是否占用一系列数字,将其考虑在内并检查该范围内所有数字的素数？