小编Val*_*roM的帖子

我没有太多使用这两种方法来扩展类或创建针对类的扩展方法的经验.通过寻找其他人的工作,我在这里有一个问题.

我看到人们使用parital类来扩展项目中的实体类.同时,在同一个项目中,还有另一个包含很多实体类扩展方法的文件夹.

这样做是对的吗？我的意思是这两种方式都运作良好.当我想要扩展课程时,你能给我一些真正的练习吗？

我只是想知道方法是什么？在什么样的场景中我可以使用这种方法.

我最初的想法是RunSynchronously调用异步方法并同步运行它而不会造成死锁问题.wait().

但是,根据MSDN,

通常,任务在线程池线程上异步执行,不会阻塞调用线程.通过调用RunSynchronously()方法执行的任务与当前的TaskScheduler相关联,并在调用线程上运行.如果目标调度程序不支持在调用线程上运行此任务,则将调度任务以在调度上执行,并且调用线程将阻塞,直到任务完成执行

为什么在这里需要一个TaskScheduler,如果任务将在调用线程上运行？

我已经设置了一个路由模板:

    config.Routes.MapHttpRoute(
        name: "DefaultApi",
        routeTemplate: "api/{controller}/{id}/{*wildcard}",
        defaults: new { id = RouteParameter.Optional }
        );

控制器的动作签名:

public IEnumerable<object> Get(Int64 id,string abc)

我尝试将其与URL http://mymachine.com/api/Individuals/1?abc=4匹配,但它给了我一个例外

{"$ id":"1","Message":"发生错误.","ExceptionMessage":"对象引用未设置为对象的实例.","ExceptionType":"System.NullReferenceException", "StackTrace":"在System.Web.Http.ValueProviders.Providers.RouteDataValueProvider.d__4.MoveNext()\ r \n

奇怪的是,http: //mymachine.com/api/Individuals？id = 1&abc = 4确实与控制器,动作和参数相匹配.

我想: " (编号)的" "API/{控制器}/{ID}/{*}通配符"将起作用.

为什么？

我有一个A类方法

public IList<T> MyMethod<T>() where T:AObject

我想在另一个泛型类B中调用此方法.此T没有任何约束.

public mehtodInClassB(){
    if (typeof(AObject)==typeof(T))
    {
      //Compile error here, how can I cast the T to a AObject Type
      //Get the MyMethod data
        A a = new A();
        a.MyMethod<T>();
    }
}

C类继承自AObject类.

B<C> b = new B<C>();
b.mehtodInClassB() 

有什么想法吗？

在提醒之后...更新:

是.我真正想做的是

typeof(AObject).IsAssignableFrom(typeof(T))

不

typeof(AObject)==typeof(T))

我们的产品是基于Web的课程管理系统.我们有10多个客户,未来我们可能会有更多的客户.(Asp.net,SQL Server)

目前,如果我们的客户需要额外的功能或定制的业务逻辑,我们将更改数据库架构和代码以满足需求.

(我们只有一个分支代码库和一个数据库模式)

为了使更改不会影响彼此的路由,我们使用客户端标志,该标志在Web配置文件中定义,因此这些额外的字段和业务逻辑仅应用于特定客户的系统.

if(ClientId = 'ABC')
{
   //DO ABC Stuff
}
else
{
   //Normal Route
}

我们的一位高级同事说,通过这种方式,像我们这样的小公司可以节省资源来支持多种资源.

但我的感觉是,这种策略使我们的代码和数据库更难维护.

那里有人遇到类似的情况？你怎么处理？

更新:如果对于SO来说这不是一个正确的问题,有人可以将此问题转移到正确的stackexchange站点吗？

Update2:你是对的.代码现在变得很臭,我肯定迟早会成为一场噩梦.我们公司正在做产品并省力,其他客户的后期产品都是基于前一个.我知道理想的方法是将@ ej-brennan开发团队分成两部分.一个团队致力于核心产品,并使其高度可定制,团队两个团队致力于为特定客户定制.但是,如果我们公司这么小,那真是一个两难的局面.:(

我不确定这是不是问题.

如果我在这里使用List,它在root/xml/metadata中都有效吗？op =竞赛和root/Competitions

[DataContract]
public class CompetitionsResponse : IHasResponseStatus
{
    [DataMember]

    public List<Competitions> Competitions { get; set; }

    //Auto inject and serialize web service exceptions
    [DataMember]
    public ResponseStatus ResponseStatus { get; set; }
}

HTTP/1.1 200 OK Content-Type:application/xml Content-Length:length

<CompetitionsResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/FSI.API.ServiceModel">
  <Competitions>
    <Competitions>
      <CompName>String</CompName>
      <CompType>String</CompType>
      <CompetitionID>0</CompetitionID>
    </Competitions>
  </Competitions>
  <ResponseStatus xmlns:d2p1="http://schemas.servicestack.net/types">
    <d2p1:ErrorCode>String</d2p1:ErrorCode>
    <d2p1:Errors>
      <d2p1:ResponseError>
        <d2p1:ErrorCode>String</d2p1:ErrorCode>
        <d2p1:FieldName>String</d2p1:FieldName>
        <d2p1:Message>String</d2p1:Message>
      </d2p1:ResponseError>
    </d2p1:Errors>
    <d2p1:Message>String</d2p1:Message>
    <d2p1:StackTrace>String</d2p1:StackTrace>
  </ResponseStatus>
</CompetitionsResponse>

但如果我使用"IEnumerable"

[DataContract]
public class CompetitionsResponse : IHasResponseStatus
{
    [DataMember]
    public IEnumerable<Competitions> Competitions { get; set; }

    //Auto …

偶然我在工作中创建了一个错误。该错误的原因是一段C＃代码，例如

public ClassA{
        public string AProperty
        {
            get
            {
                return AProperty;
            }
            set
            {
                AProperty = value;
            }
        }
}

您可以构建它，并且可以毫无例外地运行它。但是它将创建一个无限循环。例如，在设置AProperty时，它总是尝试将值分配给自己。

谁知道为什么在C＃中编译器会允许这种语法？

我检查了Nuget提交过程，但未发现有关基本检查或审阅过程的任何信息。

那么，如果有人提交了一个电子邮件模板帮助程序包，但实际上确实进行了电子邮件嗅探，那该怎么办？

如果我错过了这里，请纠正我。

只是想知道使用 WhenAll 和 ContinueWith 时任务结果的顺序是什么。这些结果是否保证与任务 ID 的顺序相同？

我写了下面的代码

public static async Task<string> PrintNumber(int number)
{
    return await Task.Delay(number*1000).ContinueWith(_=>
    {
        Console.WriteLine(number);return "TaskId:"+Task.CurrentId+" Result:"+number;
    });
}

public static void Main()
{

    Task.WhenAll(new[]
    {
        PrintNumber(3),
        PrintNumber(2),
        PrintNumber(1),

    }).ContinueWith((antecedent) => 
    { 
        foreach(var a in antecedent.Result)
        {
            Console.WriteLine(a);
        }
    });
}

并在 linqpad 中运行几次，得到相同的结果

1
2
3
TaskId:15 Result:3
TaskId:14 Result:2
TaskId:13 Result:1

或者

1
2
3
TaskId:18 Result:3
TaskId:17 Result:2
TaskId:16 Result:1

我理解的理论概念是将一个引用类型变量分配给另一个引用类型变量，仅复制引用，而不复制对象。将一个值类型变量分配给另一个值类型变量，即复制该对象。但我无法发现代码中的不同之处。有人能指出以下两个代码块之间的区别吗？谢谢你！

参考类型分配

using System;

class Employee
{
    private string m_name;

    public string Name
    {
        get { return m_name; }
        set { m_name = value; }
    }
}

class Program
{
    static void Main()
    {
        Employee joe = new Employee();
        joe.Name = "Joe";

        Employee bob = new Employee();
        bob.Name = "Bob";

        Console.WriteLine("Original Employee Values:");
        Console.WriteLine("joe = " + joe.Name);
        Console.WriteLine("bob = " + bob.Name);

        // assign joe reference to bob variable
        bob = joe;

        Console.WriteLine();
        Console.WriteLine("Values After Reference Assignment:");
        Console.WriteLine("joe = …

Git新秀在这里。我将多个提交压缩为一个提交，并将单个提交已推送至远程存储库。现在，我想找回一些压缩的提交。可能吗？