小编Geo*_*kov的帖子

我有myService使用myOtherService,它进行远程调用,返回promise:

angular.module('app.myService', ['app.myOtherService'])
  .factory('myService', [
    myOtherService,
    function(myOtherService) {
      function makeRemoteCall() {
        return myOtherService.makeRemoteCallReturningPromise();
      }

      return {
        makeRemoteCall: makeRemoteCall
      };      
    }
  ])

为了进行单元测试myService我需要模拟myOtherService,这样它的myService方法返回一个promise.我是这样做的:

describe('Testing remote call returning promise', function() {
  var myService;
  var myOtherServiceMock = {};

  beforeEach(module('app.myService'));

  // I have to inject mock when calling module(),
  // and module() should come before any inject()
  beforeEach(module(function ($provide) {
    $provide.value('myOtherService', myOtherServiceMock);
  }));

  // However, in order to properly construct my mock
  // I need $q, which can …

在Java中,您可以将方法标记为final,以使其无法覆盖.

在C#中,您必须将方法标记为虚拟,以便可以覆盖.

这是否意味着在C#中你应该将所有方法标记为虚拟(除了一些你不想被覆盖的方法),因为很可能你不知道你的类可以以什么方式被继承？

以下是类与C#中的结构不同的唯一方法(如果我错了请纠正我):

• 类变量是引用,而struct变量是值,因此struct的整个值被复制到赋值和参数传递中
• 类变量是存储在堆栈上的指针,指向堆上的内存,而struct变量作为值存储在堆上

假设我有一个不可变的结构,即包含初始化后无法修改的字段的结构.每次我将此结构作为参数传递或在赋值中使用时,该值都将被复制并存储在堆栈中.

然后假设我使这个不可变的结构成为一个不可变的类.此类的单个实例将创建一次,并且只有对类的引用将被复制到赋值和参数传递中.

如果对象是可变的,则这两种情况下的行为会有所不同:当一个人改变对象时,在第一种情况下,结构的副本将被修改,而在第二种情况下,原始对象将被改变.但是,在这两种情况下,对象都是不可变的,因此这个对象的用户实际上是类还是结构没有区别.

由于复制引用比复制struct便宜,为什么要使用不可变结构？

此外,由于可变结构是邪恶的,看起来根本没有理由使用结构.

我哪里错了？

在Java中,字符串是不可变的.如果我们有一个字符串并对其进行更改,我们将获得由同一个变量引用的新字符串:

String str = "abc";
str += "def"; // now str refers to another piece in the heap containing "abcdef"
              // while "abc" is still somewhere in the heap until taken by GC

据说 int和double在C#中是不可变的.这是否意味着当我们有int并稍后更改它时,我们会得到同一个变量"指向"的新int？同样的事情,但堆栈.

int i = 1;
i += 1; // same thing: in the stack there is value 2 to which variable
        // i is attached, and somewhere in the stack there is value 1

那是对的吗？如果没有,int以什么方式不可变？

为什么嵌套宏在一种情况下有效，而在另一种情况下则无效？

情况1：

#define name(val) #val
#define name2(front, back) name(front ## back)
...

printf("%s\n", name2(foo, bar));   // foobar

案例2：

#define paste(front, back) front ## back
#define name(val) #val
#define name2(front, back) name(paste(front, back))
...


printf("%s\n", name2(foo, bar));   // paste(foo, bar)

我收到此错误,它看起来像是因为不同的线程正在访问相同的Bitmap对象.但是我随处可以使用锁.

public class MySingleInstanceClass
{
    private Object locker = new Object();

    private Bitmap myImage = new Bitmap(100, 100);

    public Bitmap MyImage
    {
        get
        {
            lock (locker)
                return myImage;
        }
        private set
        {
            lock (locker)
                myImage = value;
        }
    }

    private void Refresh()
    {
        lock (locker)
        {
            var g = Graphics.FromImage(myImage);
            // do more processing
        }
    }
}

类MySingleInstanceClass只有一个实例.呼叫MyImage并且Refresh()可能来自不同的线程.据我所知,内部代码lock(locker)在另一个线程完成之前不会被执行,但我仍然得到错误.任何人都可以指出代码中的缺陷吗？

异常看起来像这样:

System.Drawing.dll中发生了'System.InvalidOperationException'类型的第一次机会异常

错误:对象当前正在其他地方使用.

在System.Drawing.Graphics.FromImage(图片图片)

at(指向包含var g = Graphics.FromImage(myImage)的行;)

我看到了这样的实现:

class MyClass
{
    private static readonly MyClass _instance = new MyClass();

    public static MyClass Instance{
        get{ return _instance; }
    }
}

为什么不简单？

class MyClass
{
    public static readonly MyClass Instance = new MyClass();
}

我担心人们总是使用getter-setter模式:

    public int MyVariable { get; private set; }

    public void SomeFunction(){
        MyVariable = 10;
    }

据我所知,编译为:

    private int myVariable;

    public int GetMyVariable(){
        return myVariable;
    }

    private void SetMyVariable(int value){
        myVariable = value;
    }

    public void SomeFunction()
    {
        SetMyVariable(10);
    }

如果频繁使用,它不会影响程序的性能吗？这样做是不是更好:

    private int myVariable;
    public int MyVariable { get {return myVariable; } }

    public void SomeFunction(){
        myVariable = 10;
    }

假设我们在Flash中有1 fps的动画,其中每个帧都有一个运行100 ms的脚本.据我所知,Flash中的动画工作原理如下:

0ms: Begin executing Frame 1's frame script
100ms: Finish executing Frame 1's frame script
1000ms: Begin rendering Frame 1's content and frame-script output
1050ms: Finish rendering Frame 1's content and frame-script output

1051ms: Begin executing Frame 2's frame script
1151ms: Finish executing Frame 2's frame script
2000ms: Begin rendering Frame 2's content and frame-script output
2050ms: Finish rendering Frame 2's content and frame-script output

2051ms: Begin executing Frame 3's frame script
2151ms: Finish executing Frame 3's frame …