小编And*_*dre的帖子

我对打印(回显)到控制台的各种方法有点困惑.我已经看到有多种方法可以将输出写入控制台,例如:

Write-Host "Hello world1"
"Hello World2"
Out-Host -InputObject "Hello World3"

这三种方式都将打印到控制台.中间的一个更简单,更简洁,更容易使用.我还发现当你编写一个函数时:

function GetValues()
{
    "1"
    "2"
}

它仍然在管道中返回两个字符串:

我仍然可以打印出值:

foreach ($s in GetValues)
{
    Write-Host "s: " $s
}

我发现的事情是,仅使用引用的字符串并不总是出现在自定义主机上,而且我必须使用Write-Host来获取要在自定义主机上打印的值.

不知怎的,我发现这令人困惑.被"Print something"认为是一个别名Write-Host或有什么意图？

我知道网站上有一些答案,如果这有任何重复,我道歉,但我找到的所有答案都没有做我想做的事情.

我正在尝试指定方法信息,因此我可以通过不使用字符串以类型安全的方式获取名称.所以我试图用表达式提取它.

假设我想在此界面中获取方法的名称:

public interface IMyInteface
{
    void DoSomething(string param1, string param2);
}

目前我可以使用THIS方法获取名称:

 MemberInfo GetMethodInfo<T>(Expression<Action<T>> expression)
 {
        return ((MethodCallExpression)expression.Body).Method;
 }

我可以调用helper方法如下:

var methodInfo = GetMethodInfo<IMyInteface>(x => x.DoSomething(null, null));
Console.WriteLine(methodInfo.Name);

但我正在寻找我可以获取方法名称而不指定参数的版本(null,null)

像这样:

var methodInfo = GetMethodInfo<IMyInteface>(x => x.DoSomething);

但所有尝试都无法编译

有没有办法做到这一点？

我知道如何绑定到属性,但我如何绑定到像以下属性:Parent.Child

在Knockout JS.com上使用hello world示例:Html:

<p>First name: <input data-bind="value: firstName" /></p>
<p>Last name: <input data-bind="value: lastName" /></p>
<h2>Hello, <span data-bind="text: fullName"> </span>!</h2>
<h2>ChildProperty: <span data-bind="text: parentProperty.childProperty"> </span>!</h2>

使用Javascript:

var ViewModel = function(first, last) {
this.firstName = ko.observable(first);
this.lastName = ko.observable(last);
this.parentProperty = ko.observable(
    {
        childProperty: "I am a child Property"
    });

this.fullName = ko.computed(function() {
    // Knockout tracks dependencies automatically. It knows that fullName depends on firstName      and lastName, because these get called when evaluating fullName.
        return this.firstName() + " " …

我想知道设计DTO对象构造函数的最佳实践是什么.

说我有这样的Dto对象:

class CustomerDto
{
    public string Name { get; set; }
    public string Surname { get; set; }
    public string Phone { get; set; }
    ...
}

有几种方法可以构造对象:

我可以声明一个构造函数:

public CustomerDto(string name, string surname, string phone, ...)
{
    this.Name = name;
    this.Surname = surname;
    this.Phone = phone;
    ...
}

当您看到此构造函数并立即结束SRP(单一责任)违规时？

尽管这些属性都是相关的.

人们也可以说没有必要验证属性,因为这是一个DTO并且没有行为,而且行为应该放在这个映射的域对象上.

在C#中,我们还可以更优雅地构造此对象:

var dto = new CustomerDto ()
{
    Name = "Some name",
    Surname = "Some surname"
}

或者使用流畅的构建器或NBuilder等框架.

还有自动映射框架的使用,如Automapper.问题还在于使用Ioc容器,ctor变得复杂,以及交换参数的风险,例如,你传递姓氏在哪里,反之亦然,验证可能会错过这个更容易然后如上所述的显式映射.

请帮助说服我哪种方式更好.

我正在寻找有关为IoC设计对象的最佳方法的建议

假设我有一个对象(Service)依赖于向Ioc注册的DataContext.

但它还需要一个名称属性,我可以像这样设计对象:

class Service
{
    public Service(IDataContext dataContext, 
        string name)
    {
        this._dataContext = dataContext;
        this._name = name
    }

    public string Name
    {
        get
        {
            return _name;
        }
    }
}

问题是使用Ioc容器变得非常复杂,因为字符串对象如名称不容易注册,并且Ioc容器的使用变得复杂:因此解决方案变得混乱:

var service = Ioc.Resolve<Service>( ?? )

另一种方法是将其设计如下:

class Service
{
   public Service(IDataContext dataContext)
   {
        this._dataContext = dataContext;
   }

    public string Name { get; set; }
} 

分辨率现在更容易:

var service = Ioc.Resolve<Service>();
service.Name = "Some name";

唯一的缺点是不再需要指定名称.我想听听DI或IoC专家如何设计这个并且仍然对混凝土Ioc容器技术保持相当不可知.

我知道很多取决于你想如何使用它,如果name真的是可选的,选项2将是完美的.但是在需要名称的情况下,你可以在代码的另一个点添加验证步骤,而是去设计使Ioc更简单.

思考？

我正在尝试创建一个C dll的包装器,我试图调用一个具有回调函数的函数,接收一个对象作为传回的指针.

.h文件delares

extern int SetErrorHandler(void (*handler) (int, const char*, void*),
                              void *data_ptr);

处理程序是一个回调函数,在发生错误时调用,data_ptr是传递给你的任何对象(状态),对于我的应用程序就是这个(当前对象).

我能够在一个dll中调用函数,它使用编组的常量类型,如简单类型字符串,整数等.但我无法弄清楚如何编写一个指向C#对象的指针作为状态.

为了通过在这里搜索我已经找到的对象引用传递对象引用,否则似乎我需要一个结构类型来能够编组该函数,所以我创建了一个结构来保存我的对象:

[StructLayout(LayoutKind.Sequential)]
struct MyObjectState
{
   public object state;
}

编辑:我试图在属性[MarshalAs(UnmanagedType.Struct, SizeConst = 4)]上放置一个属性:public object state但是这会产生相同的错误,所以我删除了它,似乎它无论如何都不会起作用.

该struct包含一个对象属性,用于保存回调函数的任何对象.

我在C#中声明了委托如下:

delegate void ErrorHandler(int errorCode, IntPtr name, IntPtr data);

然后我在C#中声明了导入函数,如下所示:

[DllImport("somedll.dll", CallingConvention = CallingConvention.Cdecl)]
static extern int SetErrorHandler handler, IntPtr data);

然后我在我的C#代码中创建了一个回调函数:

void MyErrorHandler(int errorCode, IntPtr name, IntPtr data)
{
    var strName = Marshal.PtrToStringAnsi(name);
    var state = new MyObjectState();
    Marshal.PtrToStructure(data, state);
    Console.WriteLine(strName);
}

我可以调用库函数如下:

var …

我想指的是在之前使用的例子SO 与鸭和鸭电:

public interface IDuck
{
    void Swim();
}

public class Duck : IDuck
{
    public void Swim()
    {
        //do something to swim
    }
}

 public class ElectricDuck : IDuck
{
    public void Swim()
    {
        if (!IsTurnedOn)
            return;

        //swim logic  
    }

    public void TurnOn()
    {
        this.IsTurnedOn = true;
    }

    public bool IsTurnedOn { get; set; }
}

LSP的原始违规将如下所示:

 void MakeDuckSwim(IDuck duck)
    {
        if (duck is ElectricDuck)
            ((ElectricDuck)duck).TurnOn();
        duck.Swim();
    }

作者的一个解决方案是将Logic放入电动鸭子的游泳方法中以使自己开启:

public class ElectricDuck : IDuck
{
    public void Swim() …

出于某种原因,我正在努力通过使用通用基类从通用接口实现属性,如下所示:

public interface IParent<TChild> where TChild : IChild
{
    TChild Child { get; }
}

public interface IChild { }

然后我有一个基类:

public class ParentBase<TChild> : IParent<TChild> where TChild : IChild
{
    private TChild _child;
    public ParentBase(TChild child)
    {
        this._child = child;
    }
    #region IParent<TChild> Members

    public TChild Child
    {
        get { return _child; }
    }

    #endregion
}

现在我有一个新的Parent Derivative和Child对象,如下所示:

public class MyChild : IChild { }

public class MyParent : ParentBase<MyChild>, IParent<IChild> 
{
    public MyParent(MyChild child)
        : base(child)
    {
    } …

首先，我必须为自己是一个 IL 菜鸟而道歉。我在生成 IL 代码来调用具有此签名的方法时遇到困难：

public void CallMethod2(string name, object[] args, object[] genericArgs)

我可以调用一个具有单个数组的方法，如下所示：

public void CallMethod1(string name, object[] args)

使用以下 IL 作品：

ILGenerator ilgen = myMethod.GetILGenerator();
var il = ilgen;
MethodInfo invokerMethod = typeof(Proxy<T>).GetMethod("CallMethod1", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldstr, method.Name);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Newarr, typeof(System.Object));
il.Emit(OpCodes.Stloc_0);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ldarg, 1);
il.Emit(OpCodes.Stelem_Ref);
il.Emit(OpCodes.Ldloc_0);

il.Emit(OpCodes.Call, invokerMethod);
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ret);

但随后我使用以下 IL 尝试使用此 IL 调用 CallMethod2：

ILGenerator ilgen = myMethod.GetILGenerator();
var il = ilgen;
MethodInfo invokerMethod = typeof(Proxy<T>).GetMethod("CallMethod2", BindingFlags.Instance | BindingFlags.Public | …

是否有人有一个简单但很好的解释以及可能的C＃.NET类或内建的库或第三方库，它们是Microkernel体系结构模式的一个很好的例子。

对我来说，这有点含糊，并且大多数情况下看起来像是处于最低设计水平的类。但是我们从不将其称为微内核，而是我们的核心程序集。

例如，我正在努力了解os内核之外的相关性。

谢谢

我是IoC和Castle Windsor的新手.

问题与IoC有关,但我选择Castle作为我的首选武器.

我立即遇到一个问题,似乎无法从配置文件或单例构造容器.

似乎对我有用的唯一方法是使用Builder函数,每次构造整个容器,然后让我指定类型,看看这个例子:

我有一个观点:

public interface IView
{
}

此视图有两个具体实现:

public class ConcreteViewA : IView
{
}

public class ConcreteViewB : IView
{
}

我有一个操作视图的控制器:

public class Controller
{
    public Controller(IView view) { }
    public void Load() { }
}

我创建了一个构造我的IoC容器并注册常见类型的函数,我可以注册的唯一类型是我的控制器,因为这一切都保持不变:

WindsorContainer BuildContainer()
    {
        var container = new WindsorContainer();
        container.Register(Component.For<Controller>().ImplementedBy<Controller>());
        return container;
    }

我有2个(Root)入口点:

void RootMethod1()
    {
        var container = BuildContainer();
        container.Register(Component.For<IView>().ImplementedBy<ConcreteViewA>());
        var controller = container.Resolve<Controller>();
        controller.Load();
    }

    void RootMethod2()
    {
        var container = BuildContainer();
        container.Register(Component.For<IView>().ImplementedBy<ConcreteViewB>());
        var controller …