在C# Coding Conventions 中，当变量的类型从赋值的右侧很明显时，为什么 Microsoft 建议使用隐式类型？
我知道没有必要声明它，因为它很明显，但为什么要提出建议？显式键入不是使代码更易于遵循吗？
var str1 = "This is clearly a string.";
对比
string str2 = "This is clearly a string.";
这有编译时间的好处吗？
我有这个
var result = general.GetInformation(int.Parse(ID), F_account, F_Info, Types);
这个GetInformation是我的Entity.Getinformation类..当我试图分配结果时,我得到了无法分配给隐式类型的局部变量？
var result = ?
我应该在全球分配什么？
谢谢
我编写了一个扩展Iterator [A]的自定义特性,我希望能够使用我在另一个方法返回的迭代器[A]上编写的方法.这可能吗？
trait Increment[+A] extends Iterator[A]{
def foo() = "something"
}
class Bar( source:BufferedSource){
//this ain't working
def getContents():Increment[+A] = source getLines
}
我仍然试图绕过整个隐含的东西而不是在Bar对象定义中编写方法.我将如何以上述方式包装这样的物品？
例1
var test = Byte.MaxValue;
Console.WriteLine(test + " : " + test.GetType().Name);
结果255:字节
例2
var test = 255;
Console.WriteLine(test + " : " + test.GetType().Name);
结果255:Int32
例3
var test = 10;
Console.WriteLine(test + " : " + test.GetType().Name);
结果10:Int32
例4
var test = 255;
test = Int64.MaxValue;
Console.WriteLine(test + " : " + test.GetType().Name);
结果:错误:无法将类型long隐式转换为int
我的问题是为什么C#在使用时默认类型为Int32 var.
可能重复:
C#3.0中var关键字的优点
昨天我偶然发现MS的推荐,我应该尽可能使用var:
http://msdn.microsoft.com/en-us/library/ff926074.aspx
我一直认为使用正确的类型将有助于记录代码,并在编译时帮助查找错误.
这个推荐背后的原因是什么？
最佳托马斯
我正在使用ReSharper帮助我发现我的代码中可能存在的错误,虽然不是错误,但它仍然抱怨我应该使用var关键字而不是在声明上显式键入变量.我个人认为,如果我写的话,对我和任何读我代码的人都会更清楚
IList<T> someVar = new List<T>();
代替
var someVar = new List<T>();
知道两种方式之间没有性能差异,我应该忽略这些提示还是坚持使用var关键字？
它只是一个品味的问题,还是隐含地输入变量的好习惯？
当我在代码中使用命名常量时,我一直在尝试减少隐式类型转换.例如而不是使用
const double foo = 5;
我会用
const double foo = 5.0;
这样就不需要进行类型转换.但是,在我做这样的事情的表达中......
const double halfFoo = foo / 2;
是否将2评估为整数并且是否隐式转换？我应该使用2.0吗？
因为我不熟悉隐式打字; 你能否告诉我两者之间的主要区别:
var foo = new Love();
和
object foo = new Love();
在重写我的事件调用函数以一般地处理事件及其参数之后,我开始检查我的代码(以匹配更改),并且我注意到编译器隐式地进行了泛型调用.
这是我的功能:
private void InvokeEvent<TArgs>(EventHandler<TArgs> invokedevent, TArgs args)
where TArgs : EventArgs
{
EventHandler<TArgs> temp = invokedevent;
if (temp != null)
{
temp(this, args);
}
}
这是调用函数的行:
InvokeEvent(AfterInteraction, result);
这编译没有问题,智能感知甚至显示"正确"调用(与部分).
这是一个编译器功能(通用类型实际上可以直接从第二个参数推断出来),还是我疯了什么都没有,并且忽略了这一点？
我有一个Map可能有一个相同类型的嵌套地图.每个嵌套映射都有一个返回外部映射的引用.
我已经定义了一个findValue查看当前地图的方法,如果找不到任何内容,则会转到其父级,依此类推,直到找到null最外层的父级SymbolTable.
我把这种行为成Try,这样我可以匹配Success和Failure; 但是为了避免使用类型a-la,Try[Try[Try[ ... Try[TableVaue]... ]]]我将输出平坦化.
在尝试呼叫时,flatten我收到以下错误:Cannot prove that Object <:< Try[U]
以下是相关的代码:
class SymbolTable(val parentScope: SymbolTable) {
type TableValue = (TypeInfo, Option[Expression], Option[SymbolTable])
private val contents: mutable.Map[String, TableValue] = mutable.Map.empty
private def findValue(key: String): Try[TableValue] = Try {
if (contents contains key) contents(key)
else parentScope findValue key
}.flatten
}
所以我的问题是:如何在没有对我的代码进行任何重大重构的情况下完成这项工作？
我知道我可以使用类的隐式转换,如下所示,但有没有办法让一个实例返回没有强制转换或转换的字符串？
public class Fred
{
public static implicit operator string(Fred fred)
{
return DateTime.Now.ToLongTimeString();
}
}
public class Program
{
static void Main(string[] args)
{
string a = new Fred();
Console.WriteLine(a);
// b is of type Fred.
var b = new Fred();
// still works and now uses the conversion
Console.WriteLine(b);
// c is of type string.
// this is what I want but not what happens
var c = new Fred();
// don't want to have to cast it …