小编Ken*_*Kin的帖子

• 破碎的代码

  public static partial class LogicExtensions {
      public static bool Implies<T>(this T premise, T conclusion) {
          return conclusion.Infers(premise);
      }
  
      public static bool Infers<T>(this T premise, T conclusion) {
          return premise.Implies(conclusion);
      }
  }
  

  Run Code Online (Sandbox Code Playgroud)

上面的代码希望表达:

结论推断了前提,因为前提暗示了结论.

前提暗示了结论,因为结论推断了前提.

这将是循环推理,肯定会导致堆栈溢出.然后我重新设计如下:

• 工作代码

  public delegate bool Paradox<T>(T premise, T conclusion, Paradox<T> predicate=null);
  
  public static partial class LogicExtensions {
      public static bool Implies<T>(this T premise, T conclusion, Paradox<T> predicate=null) {
          if(null==predicate)
              return conclusion.Infers(premise, Implies);
  
          if(Infers!=predicate)
              return predicate(premise, conclusion);
  
          return LogicExtensions.Implies(conclusion as IConvertible, premise as IConvertible); …

  Run Code Online (Sandbox Code Playgroud)

方差有效性的精确规则有点模糊,不具体.我将列出关于什么使类型有效 - 协变的规则,并将一些查询和个人注释附加到每个规则.

A型是有效的协变,如果它是:

1)指针类型或非泛型类型.

指针和非泛型类型在C#中不是变体,除了数组和非泛型委托.通用类,结构和枚举是不变的.我在这儿吗？

2)数组类型T [],其中T是共同有效的.

所以这意味着如果T数组的元素类型T[]是协变的(引用或数组元素类型),那么数组是协变的,如果元素类型是不变的(值类型),那么数组类型是不变的.数组在C#中不能逆变.我在这儿吗？

3)泛型类型参数类型,如果它未被声明为逆变.

我们通常说泛型类型在参数类型上是变体,但是参数类型在它自己的变量上.这是另一种简短形式吗？例如,泛型类型T<out D>是协变的D(因此协变有效),因此我们可以说类型参数D是协变有效的.我对吗？

4)构造的类,结构,枚举,接口或委托类型X可能是协同有效的.为了确定它是否,我们以不同方式检查每个类型参数,具体取决于相应的类型参数是声明为covariant(out),contravariant(in)还是invariant(both).(当然,类和结构的泛型类型参数永远不会被声明为'out'或'in';它们将始终是不变的.)如果第i个类型参数被声明为covariant,那么Ti必须是covariantly有效的.如果它被宣布为逆变,那么Ti必须是有效的.如果它被声明为不变量,则Ti必须是不变的有效.

最后一条规则,从上到下,完全不明确.

我们是否在讨论泛型类型的所有in/out/invariant类型参数的方差？根据定义,泛型类型一次可以是一种类型参数的协变/逆变/不变量.为了协变或不变,在这种情况下,立即对它的所有类型参数都没有任何意义.这意味着什么？

向前进.为了确定泛型类型是否具有协变有效性,我们检查其类型参数(而不是类型参数).因此,如果相应的类型参数是covariant/contravariant/invariant,那么type参数分别是covariantly/contravariantly/invariantly有效...

我需要更深入地解释这条规则.

编辑:谢谢埃里克.非常感激!

我完全理解有效/无差异/不变的有效意义.如果类型绝对不是逆变的,那么类型是有效的,这意味着它可以是不变的.完全没问题!

对于第4条规则,您将遵循如何确定构造的泛型类型是否在协规中有效的过程,如规则中所定义.但是,如何确定声明为covariant(out)的类型参数是否具有协变有效性？

例如,在通用接口I {...}的闭合构造接口I {}中,不应该在通用接口声明中将类型参数声明为协变类型参数(out U)这一事实意味着类型参数对象是协变的吗？我认为应该.Cuz这就是协变的定义.object

另外,第二条规则:

2)数组类型T [],其中T是共同有效的.

什么是数组元素类型T是有效的协变意味着什么呢？你的意思是元素类型是值类型(在这种情况下是不变的)或引用类型(在这种情况下是协变)？

Cuz投影T→ T[]只有T参考类型才是变体.

我正在使用优化几个js文件r.js.它之前工作正常.最近,我修改了一些js代码,添加代码为:

var x = 08;

然后它显示

错误:使用esprima解析文件D://webroot/js/a.js

错误:第45行:意外的令牌ILLEGAL.

第45行是我添加的地方var x = 08,09也会显示错误.似乎数字从0开始同时包含8或9非法.也许他们被视为bese 8号..？

我怎么能r.js忽略这一点并仍然优化js文件？

我有一个名为小班Tank有一个叫做公共成员Location这是一个Rectangle(一个结构).我写的时候:

Tank t = new Tank();
t.Location.X+=10;

一切正常,坦克移动.

但在我将成员更改为属性后,我再也无法使用此语法.它不编译,因为t.Location它现在是一个属性(它是函数)并返回该位置的临时副本(因为它是一个值类型).

我Location现在可以使用的唯一方法是做这样的事情:

k = t.Location 
k.X +=10;
t.Location = k;

是否有任何解决方法可以帮助我不要编写这些丑陋的代码,并使用直观的a+=10;语法？

我正在尝试计算一系列数字的每个数字的数字乘积,例如:

21,22,23 ...... 98,99 ..

将会:

2,4,6 ... 72,81 ..

为了减少复杂性,我会考虑只有[ 连续编号中的数字的有限长度],如从001到999或从0001到9999.

但是,例如,当序列很大时1000000000,重复提取数字然后乘以每个数字将是低效的.

基本思路是跳过我们在计算过程中会遇到的连续零点,如:

using System.Collections.Generic;
using System.Linq;
using System;

// note the digit product is not given with the iteration
// we would need to provide a delegate for the calculation
public static partial class NumericExtensions {
    public static void NumberIteration(
            this int value, Action<int, int[]> delg, int radix=10) {
        var digits=DigitIterator(value, radix).ToArray();
        var last=digits.Length-1;
        var …

我到目前为止的代码如下,我想要解决的是摆脱try-catch:

public static bool IsNeverValidGenericArgument(this Type type) {
    var elementType=type.GetElementType();

    if(null!=elementType) {
        if(type.IsArray)
            try {
                typeof(IList<>).MakeGenericType(elementType);
                return false;
            }
            catch(ArgumentException) {
            }
            catch(TypeLoadException) {
            }

        return true; // pointer or byref 
    }

    return
        typeof(void)==type||typeof(RuntimeArgumentHandle)==type
        ||
        typeof(ArgIterator)==type||typeof(TypedReference)==type;
}

我想写的动态结构类型的代码,我的代码将调用GetInterfaces()每种类型过去了,但一些由消费者的代码中传递的类型可能会导致TypeLoadException在RuntimeType内部(如typeof(ArgIterator).MakeArrayType().MakeArrayType()在3.5,而不是4.0+)我需要先检查它是否永远不是一个有效的泛型参数.try-catch有效,但没有好处.

请注意,它抛出的情况可能因.Net框架的不同版本而异.

编辑:

该方法的替代版本是:

public static bool IsNeverValidGenericArgument(this Type type) {
    var elementType=type.GetElementType();

    if(null!=elementType) {
        if(type.IsArray)
            return elementType.IsNeverValidGenericArgument();

        return true; // pointer or byref 
    }

    return
        typeof(void)==type||typeof(RuntimeArgumentHandle)==type
        ||
        typeof(ArgIterator)==type||typeof(TypedReference)==type;
}

但是这会报告某些类型无效,实际上不会导致异常 …

对于这个问题,我不期望解决问题的方法,但希望更好地理解事情.

一些引用规格:

• 5.1版(链接)

  §15.2.3.5Object.create(O [,Properties])

  create函数使用指定的原型创建一个新对象.调用create函数时,将执行以下步骤:

  1. 如果Type(O)不是Object或Null则抛出TypeError异常.
  2. 设obj是创建一个新对象的结果,好像是通过表达式new Object(),其中Object是具有该名称的标准内置构造函数
  3. 将obj的[[Prototype]]内部属性设置为O.
  4. 如果参数Properties存在且未定义,则将自己的属性添加到obj,就好像通过调用带有参数obj和Properties的标准内置函数Object.defineProperties一样.
  5. 返回obj.

• 第6版 - 草稿(链接)

  §19.1.3.2Object.create(O [,Properties])

  create函数使用指定的原型创建一个新对象.调用create函数时,将执行以下步骤:

  1. 如果Type(O)不是Object或Null则抛出TypeError异常.
     1. 设obj是带参数O的抽象操作ObjectCreate的结果.
     2. 如果参数属性存在且未定义,则a.返回抽象操作ObjectDefineProperties(obj,Properties)的结果.
     3. 返回obj.

如果我理解正确,两个规范都允许执行以下代码:

function F() {
}

var x=Object.create(F);

// a minimal test
alert(x.prototype.constructor===F); // true
alert(x instanceof Function) // true
alert(typeof x) // 'object'

似乎它创建了一个类型的对象派生自^{(抱歉可怜的术语..),} Function因为我在FireFox中测试过,因此x是不可调用的:

x(); // x is not a function 

我在考虑为什么它不会禁止使用构造函数O或只是创建一个有效的构造函数.

所以我想知道你期望Object.create对构造函数做什么？

我使用下面的代码来获取物理磁盘大小,但返回的大小不正确.我用其他工具检查了尺寸.

以下代码报告

总磁盘空间:8.249.955.840字节

它应该是

总磁盘空间:8.254.390.272字节

如何检索实际/正确的物理磁盘大小？在USB驱动器和普通硬盘上测试.代码很长,这里将它分开来显示.

结构:

[StructLayout(LayoutKind.Sequential)]
internal struct DiskGeometry {
    public long Cylinders;
    public int MediaType;
    public int TracksPerCylinder;
    public int SectorsPerTrack;
    public int BytesPerSector;
}

原生方法:

internal static class NativeMethods {
    [DllImport("Kernel32.dll", SetLastError=true, CharSet=CharSet.Auto)]
    public static extern SafeFileHandle CreateFile(
        string fileName,
        uint fileAccess,
        uint fileShare,
        IntPtr securityAttributes,
        uint creationDisposition,
        uint flags,
        IntPtr template
        );

    [DllImport("Kernel32.dll", SetLastError=false, CharSet=CharSet.Auto)]
    public static extern int DeviceIoControl(
        SafeFileHandle device,
        uint controlCode,
        IntPtr inBuffer,
        uint inBufferSize,
        IntPtr outBuffer, …

我有一个C#WinForm应用程序,我运行x86模式.它适用于x86模式.当我使用任何CPU模式运行此应用程序时,会出现此问题.我得到以下提到的错误:

XXXXXX.dll中出现未处理的"System.StackOverflowException"类型异常

我知道这可能是由无限循环引起的,但在这种情况下,x86模式中应该发生相同的错误.我知道这不是因为无限次迭代.它与堆栈溢出有关.

做了一些研究后,我用Editbin增加了堆栈大小

从

Editbin.exe/Stack:14000000"$(TargetDir)MyProject.exe"

至

Editbin.exe/Stack:14000000"$(TargetDir)MyProject.exe"

任何想法可能是什么原因以及我应该进入的方向？

我试图编写一个方法,尽可能简单地返回给定枚举的排列.代码:

using System.Collections.Generic;

public static partial class Permutable {
    static IEnumerable<IEnumerable<T>> PermuteIterator<T>(
        IEnumerable<T> source, int offset) {
        var count=0;

        foreach(var dummy in source)
            if(++count>offset)
                foreach(
                    var sequence in
                        Permutable.PermuteIterator(
                            source.Exchange(offset, count-1), 1+offset)
                    )
                    yield return sequence;

        if(offset==count-1)
            yield return source;
    }

    public static IEnumerable<IEnumerable<T>> AsPermutable<T>(
        this IEnumerable<T> source) {
        return Permutable.PermuteIterator(source, 0);
    }

    public static IEnumerable<T> Exchange<T>(
        this IEnumerable<T> source, int index1, int index2) {
        // exchange elements at index1 and index2
    }
}

由于代码在迭代器块中简化了,我试图使它只是LINQ的单个查询表达式.

在foreach这个代码的嵌套中有一个递归,甚至另一个可能在...之外产生foreach; …