本文将分享systemdcodingstyle的详细内容，此外，我们还将为大家带来关于c#–LINQtoEntities不识别方法’System.StringStringConvert(System.

本文将分享systemd coding style的详细内容，此外，我们还将为大家带来关于c# – LINQ to Entities不识别方法’System.String StringConvert(System.Nullable`1 [System.Double])、c# – System.String没有实现System.IConvertible接口、c# – typeof(String)与System.Type.GetType(“System.String”)的性能、CentOS 7 巨大变动之systemd取代System V init的相关知识，希望对你有所帮助。

• systemd coding style
• c# – LINQ to Entities不识别方法’System.String StringConvert(System.Nullable`1 [System.Double])
• c# – System.String没有实现System.IConvertible接口
• c# – typeof(String)与System.Type.GetType(“System.String”)的性能
• CentOS 7 巨大变动之systemd取代System V init

systemd coding style

- 8ch indent, no tabs

- Variables and functions *must* be static, unless they have a
  prototype, and are supposed to be exported.

- structs in MixedCase (with exceptions, such as public API structs),
  variables + functions in lower_case.

- The destructors always unregister the object from the next bigger
  object, not the other way around

- To minimize strict aliasing violations, we prefer unions over casting

- For robustness reasons, destructors should be able to destruct
  half-initialized objects, too

- Error codes are returned as negative Exxx. i.e. return -EINVAL. There
  are some exceptions: for constructors, it is OK to return NULL on
  OOM. For lookup functions, NULL is fine too for "not found".

  Be strict with this. When you write a function that can fail due to
  more than one cause, it *really* should have "int" as return value
  for the error code.

- Do not bother with error checking whether writing to stdout/stderr
  worked.

- Do not log errors from "library" code, only do so from "main
  program" code. (With one exception: it is OK to log with DEBUG level
  from any code, with the exception of maybe inner loops).

- Always check OOM. There is no excuse. In program code, you can use
  "log_oom()" for then printing a short message, but not in "library" code.

- Do not issue NSS requests (that includes user name and host name
  lookups) from PID 1 as this might trigger deadlocks when those
  lookups involve synchronously talking to services that we would need
  to start up

- Do not synchronously talk to any other service from PID 1, due to
  risk of deadlocks

- Avoid fixed-size string buffers, unless you really know the maximum
  size and that maximum size is small. They are a source of errors,
  since they possibly result in truncated strings. It is often nicer
  to use dynamic memory, alloca() or VLAs. If you do allocate fixed-size
  strings on the stack, then it is probably only OK if you either
  use a maximum size such as LINE_MAX, or count in detail the maximum
  size a string can have. (DECIMAL_STR_MAX and DECIMAL_STR_WIDTH
  macros are your friends for this!)

  Or in other words, if you use "char buf[256]" then you are likely
  doing something wrong!

- Stay uniform. For example, always use "usec_t" for time
  values. Do not usec mix msec, and usec and whatnot.

- Make use of _cleanup_free_ and friends. It makes your code much
  nicer to read!

- Be exceptionally careful when formatting and parsing floating point
  numbers. Their syntax is locale dependent (i.e. "5.000" in en_US is
  generally understood as 5, while on de_DE as 5000.).

- Try to use this:

      void foo() {
      }

  instead of this:

      void foo()
      {
      }

  But it is OK if you do not.

- Do not write "foo ()", write "foo()".

- Please use streq() and strneq() instead of strcmp(), strncmp() where applicable.

- Please do not allocate variables on the stack in the middle of code,
  even if C99 allows it. Wrong:

  {
          a = 5;
          int b;
          b = a;
  }

  Right:

  {
          int b;
          a = 5;
          b = a;
  }

- Unless you allocate an array, "double" is always the better choice
  than "float". Processors speak "double" natively anyway, so this is
  no speed benefit, and on calls like printf() "float"s get promoted
  to "double"s anyway, so there is no point.

- Do not invoke functions when you allocate variables on the stack. Wrong:

  {
          int a = foobar();
          uint64_t x = 7;
  }

  Right:

  {
          int a;
          uint64_t x = 7;

          a = foobar();
  }

- Use "goto" for cleaning up, and only use it for that. i.e. you may
  only jump to the end of a function, and little else. Never jump
  backwards!

- Think about the types you use. If a value cannot sensibly be
  negative, do not use "int", but use "unsigned".

- Do not use types like "short". They *never* make sense. Use ints,
  longs, long longs, all in unsigned+signed fashion, and the fixed
  size types uint32_t and so on, as well as size_t, but nothing else.

- Public API calls (i.e. functions exported by our shared libraries)
  must be marked "_public_" and need to be prefixed with "sd_". No
  other functions should be prefixed like that.

- In public API calls, you *must* validate all your input arguments for
  programming error with assert_return() and return a sensible return
  code. In all other calls, it is recommended to check for programming
  errors with a more brutal assert(). We are more forgiving to public
  users then for ourselves! Note that assert() and assert_return()
  really only should be used for detecting programming errors, not for
  runtime errors. assert() and assert_return() by usage of _likely_()
  inform the compiler that he should not expect these checks to fail,
  and they inform fellow programmers about the expected validity and
  range of parameters.

- Never use strtol(), atoi() and similar calls. Use safe_atoli(),
  safe_atou32() and suchlike instead. They are much nicer to use in
  most cases and correctly check for parsing errors.

- For every function you add, think about whether it is a "logging"
  function or a "non-logging" function. "Logging" functions do logging
  on their own, "non-logging" function never log on their own and
  expect their callers to log. All functions in "library" code,
  i.e. in src/shared/ and suchlike must be "non-logging". Everytime a
  "logging" function calls a "non-logging" function, it should log
  about the resulting errors. If a "logging" function calls another
  "logging" function, then it should not generate log messages, so
  that log messages are not generated twice for the same errors.

- Avoid static variables, except for caches and very few other
  cases. Think about thread-safety! While most of our code is never
  used in threaded environments, at least the library code should make
  sure it works correctly in them. Instead of doing a lot of locking
  for that, we tend to prefer using TLS to do per-thread caching (which
  only works for small, fixed-size cache objects), or we disable
  caching for any thread that is not the main thread. Use
  is_main_thread() to detect whether the calling thread is the main
  thread.

c# – LINQ to Entities不识别方法’System.String StringConvert(System.Nullable`1 [System.Double])

using System.Data;
using System.Data.Objects.sqlClient;

e.Result = from n in MyDB.tblBulletins
     where n.AnncStart <= DateTime.Now && n.AnncEnd > DateTime.Now && n.Approved == true
     orderby n.AnncStart descending,n.AnncDate descending
     select new
     {
        n.RecID,AnncTitle = n.AnncTitle + " <a href='bulletinAdd.aspx?ID=" + sqlFunctions.StringConvert((double)n.RecID).Trim() + "'><Edit></a>",AnncText = (n.AnncImg == null ? n.AnncText : "<a href='images/bulletin/" + n.AnncImg + "'><img src='images/bulletin/" + n.AnncImg + "'alt='Click for larger image'/></a>" + n.AnncText),Email = (n.Email == null ? "" : "<br/><a href='mailto:" + n.Email + "'>" + n.Email + "</a>"),n.AnncType,n.AnncDate,n.AnncEnd,n.v_EmpBasicInfo.Name
      };

[NotSupportedException: LINQ to Entities does not recognize the method 'System.String StringConvert(System.Nullable`1[System.Double])' method,and this method cannot be translated into a store expression.]
System.Data.Entity.Core.Objects.ELinq.DefaultTranslator.Translate(ExpressionConverter parent,MethodCallExpression call) +194
System.Data.Entity.Core.Objects.ELinq.MethodCallTranslator.TypedTranslate(ExpressionConverter parent,MethodCallExpression linq) +976
System.Data.Entity.Core.Objects.ELinq.TypedTranslator`1.Translate(ExpressionConverter parent,Expression linq) +88
System.Data.Entity.Core.Objects.ELinq.ExpressionConverter.TranslateExpression(Expression linq) +148
System.Data.Entity.Core.Objects.ELinq.BinaryTranslator.TypedTranslate(ExpressionConverter parent,BinaryExpression linq) +122
System.Data.Entity.Core.Objects.ELinq.TypedTranslator`1.Translate(ExpressionConverter parent,BinaryExpression linq) +87
System.Data.Entity.Core.Objects.ELinq.TypedTranslator`1.Translate(ExpressionConverter parent,Expression linq) +88
System.Data.Entity.Core.Objects.ELinq.ExpressionConverter.TranslateExpression(Expression linq) +148
System.Data.Entity.Core.Objects.ELinq.NewTranslator.TypedTranslate(ExpressionConverter parent,NewExpression linq) +520
System.Data.Entity.Core.Objects.ELinq.TypedTranslator`1.Translate(ExpressionConverter parent,Expression linq) +88
System.Data.Entity.Core.Objects.ELinq.ExpressionConverter.TranslateExpression(Expression linq) +148
System.Data.Entity.Core.Objects.ELinq.ExpressionConverter.TranslateLambda(LambdaExpression lambda,DbExpression input) +168
System.Data.Entity.Core.Objects.ELinq.ExpressionConverter.TranslateLambda(LambdaExpression lambda,DbExpression input,DbExpressionBinding& binding) +160
System.Data.Entity.Core.Objects.ELinq.OneLambdaTranslator.Translate(ExpressionConverter parent,MethodCallExpression call,DbExpression& source,DbExpressionBinding& sourceBinding,DbExpression& lambda) +168
System.Data.Entity.Core.Objects.ELinq.SelectTranslator.Translate(ExpressionConverter parent,MethodCallExpression call) +70
System.Data.Entity.Core.Objects.ELinq.SequenceMethodTranslator.Translate(ExpressionConverter parent,SequenceMethod sequenceMethod) +47
System.Data.Entity.Core.Objects.ELinq.MethodCallTranslator.TypedTranslate(ExpressionConverter parent,MethodCallExpression linq) +141
System.Data.Entity.Core.Objects.ELinq.TypedTranslator`1.Translate(ExpressionConverter parent,Expression linq) +88
System.Data.Entity.Core.Objects.ELinq.ExpressionConverter.TranslateExpression(Expression linq) +148
System.Data.Entity.Core.Objects.ELinq.ExpressionConverter.Convert() +50
System.Data.Entity.Core.Objects.ELinq.ELinqQueryState.GetExecutionPlan(Nullable`1 forMergeOption) +563
System.Data.Entity.Core.Objects.<>c__displayClassb.<GetResults>b__a() +83
System.Data.Entity.Core.Objects.ObjectContext.ExecuteInTransaction(Func`1 func,IDbExecutionStrategy executionStrategy,Boolean startLocalTransaction,Boolean releaseConnectionOnSuccess) +499
System.Data.Entity.Core.Objects.<>c__displayClassb.<GetResults>b__9() +271
System.Data.Entity.sqlServer.DefaultsqlExecutionStrategy.Execute(Func`1 operation) +251
System.Data.Entity.Core.Objects.ObjectQuery`1.GetResults(Nullable`1 forMergeOption) +600
   System.Data.Entity.Core.Objects.ObjectQuery`1.<System.Collections.Generic.IEnumerable<T>.GetEnumerator>b__0() +89
System.Lazy`1.CreateValue() +416
System.Lazy`1.LazyInitValue() +152
System.Lazy`1.get_Value() +75
System.Data.Entity.Internal.LazyEnumerator`1.MoveNext() +40
System.Collections.Generic.List`1..ctor(IEnumerable`1 collection) +381
System.Linq.Enumerable.ToList(IEnumerable`1 source) +58

[TargetInvocationException: Exception has been thrown by the target of an invocation.]
System.RuntimeMethodHandle.InvokeMethod(Object target,Object[] arguments,Signature sig,Boolean constructor) +0
System.Reflection.RuntimeMethodInfo.UnsafeInvokeInternal(Object obj,Object[] parameters,Object[] arguments) +92
System.Reflection.RuntimeMethodInfo.Invoke(Object obj,BindingFlags invokeAttr,Binder binder,CultureInfo culture) +108
System.Reflection.MethodBase.Invoke(Object obj,Object[] parameters) +19
System.Web.UI.WebControls.QueryableDataSourceHelper.ToList(IQueryable query,Type dataObjectType) +225
System.Web.UI.WebControls.LinqDataSourceView.ExecuteSelect(DataSourceSelectArguments arguments) +549
System.Web.UI.WebControls.Repeater.GetData() +55
System.Web.UI.WebControls.Repeater.CreateControlHierarchy(Boolean useDataSource) +89
System.Web.UI.WebControls.Repeater.OnDataBinding(EventArgs e) +61
System.Web.UI.WebControls.Repeater.DataBind() +105
System.Web.UI.WebControls.Repeater.EnsureDataBound() +49
System.Web.UI.WebControls.Repeater.OnPreRender(EventArgs e) +15
System.Web.UI.Control.PreRenderRecursiveInternal() +83
System.Web.UI.Control.PreRenderRecursiveInternal() +168
System.Web.UI.Control.PreRenderRecursiveInternal() +168
System.Web.UI.Control.PreRenderRecursiveInternal() +168
System.Web.UI.Control.PreRenderRecursiveInternal() +168
System.Web.UI.Control.PreRenderRecursiveInternal() +168
System.Web.UI.Control.PreRenderRecursiveInternal() +168
System.Web.UI.Page.ProcessRequestMain(Boolean includeStagesBeforeAsyncPoint,Boolean includeStagesAfterasyncPoint) +974

using System.Data.Entity.sqlServer;

using System.Data.Objects.sqlClient;

c# – System.String没有实现System.IConvertible接口

bool IConvertible.ToBoolean(IFormatProvider provider) {
    return Convert.ToBoolean(this,provider);
}

public bool ToBoolean(IFormatProvider provider) {
    return Convert.ToBoolean(this,provider);
}

c# – typeof(String)与System.Type.GetType(“System.String”)的性能

baseline: 5572 ticks 2 ms
typeof(Test): 8757 ticks 3 ms
Type.GetType(String): 3899966 ticks 1482 ms

[MethodImpl(MethodImplOptions.NoInlining)]
static int Call(Type t)
{
    return 1;
}
static void Main(string[] args)
{
    const int Iterations = 1000000;
    int count;

    Stopwatch sw = Stopwatch.StartNew(); count = 0;
    for (int i = 0; i < Iterations; i++)
    {
        count += Call(null);
    }
    sw.Stop();
    Console.WriteLine("baseline: {0} ticks {1} ms",sw.ElapsedTicks,sw.ElapsedMilliseconds);

    sw = Stopwatch.StartNew(); count = 0;
    for (int i = 0; i < Iterations; i++)
    {
        count += Call(typeof(String));
    }
    sw.Stop();
    Console.WriteLine("typeof(Test): {0} ticks {1} ms",sw.ElapsedMilliseconds);

    sw = Stopwatch.StartNew(); count = 0;
    for (int i = 0; i < Iterations; i++)
    {
        count += Call(Type.GetType("System.String"));
    }
    sw.Stop();
    Console.WriteLine("Type.GetType(String): {0} ticks {1} ms",sw.ElapsedMilliseconds);
}

typeof(Test): 24782 ticks 9 ms
Type.GetType(String): 4783195 ticks 1818 ms

static void Main() 
{
  const int Iterations = 1000000;
  Stopwatch sw = Stopwatch.StartNew();
  for (int i = 0; i < Iterations; i++)
  {
    Type t = typeof(String);
  }
  sw.Stop();
  Console.WriteLine("typeof(Test): {0} ticks {1} ms",sw.ElapsedMilliseconds);

  sw = Stopwatch.StartNew();
  for (int i = 0; i < Iterations; i++)
  {
    Type t = System.Type.GetType("System.String");
  }
  sw.Stop();
  Console.WriteLine("Type.GetType(String): {0} ticks {1} ms",sw.ElapsedMilliseconds);
}

CentOS 7 巨大变动之systemd取代System V init

转自:http://www.ibm.com/developerworks/cn/linux/1407_liuming_init3/index.html,少有改动。

1 systemd是什么

首先systmed是一个用户空间的程序，属于应用程序，不属于Linux内核范畴，Linux内核的主要特征在所有发行版中是统一的，厂商可以自由改变的是用户空间的应用程序。

Linux内核加载启动后，用户空间的第一个进程就是初始化进程，这个程序的物理文件约定位于/sbin/init，当然也可以通过传递内核参数来让内核启动指定的程序。这个进程的特点是进程号为1，代表第一个运行的用户空间进程。不同发行版采用了不同的启动程序，主要有以下几种主流选择：

（1）以Ubuntu为代表的Linux发行版采用upstart。

（2）以7.0版本之前的CentOS为代表的System V init。

（3）CentOS7.0版本的systemd。

下面是CentOS6.5和CentOS7两个版本初始化进程的信息截图。

CentOS6.5采用的是systemV init

CentOS7 采用的是systemd

2 Systemd物理文件组成

systemd是一个完整的软件包，安装完成后有很多物理文件组成，大致分布为，配置文件位于/etc/systemd这个目录下，配置工具命令位于/bin，和/sbin这两个目录下，预先准备的备用配置文件位于/lib/systemd目录下，还有库文件和帮助手册等等。这是一个庞大的软件包。详情使用rpm -ql systemd即可查看。

先让我们看看当前系统/etc/inittab这个文件的内容，这个文件是systme V init的标准配置文件，如今变成了:

#inittabisnolongerusedwhenusingsystemd.
#
#ADDINGCONfigURATIONHEREWILLHAVENOEFFECTONYOURSYstem.
#
#Ctrl-Alt-Deleteishandledby/etc/systemd/system/ctrl-alt-del.target
#
#systemduses'targets'insteadofrunlevels.Bydefault,therearetwomaintargets:
#
#multi-user.target:analogoustorunlevel3
#graphical.target:analogoustorunlevel5
#
#Tosetadefaulttarget,run:
#
#ln-sf/lib/systemd/system/<targetname>.target/etc/systemd/system/default.target

这说明，在systemd掌权后，inittab不再起作用，也没有了“运行级”的概念。现在起作用的配置文件是/etc/systemd/system/default.target这个文件了。此文件的内容如下：

#Thisfileispartofsystemd.
#
#systemdisfreesoftware;youcanredistributeitand/ormodifyit
#underthetermsoftheGNULesserGeneralPublicLicenseaspublishedby
#theFreeSoftwareFoundation;eitherversion2.1oftheLicense,or
#(atyouroption)anylaterversion.

[Unit]
Description=multi-userSystem
Documentation=man:systemd.special(7)
Requires=basic.target
Conflicts=rescue.servicerescue.target
After=basic.targetrescue.servicerescue.target
AllowIsolate=yes

[Install]
Alias=default.target

systemd的配置文件后缀根据配置单元类型的不同而不同，主要有.service，.target等。

3 Systemd运行原理

3.1 systemd的基本概念

（1）配置单元unit

系统初始化要做很多工作，如挂在文件系统，启动sshd服务，配置交换分区，这都可以看做是一个配置单元，systemd安装功能不同把配置单元分成多种类型。

• service 后代服务进程，如httpd，MysqLd等

• soket 对应一个套接字，之后对应到一个service，类似于xinetd的功能

• device 对应udev规则标记的一个设备

• mount 系统中的一个挂载点，systemd据此进行自动挂载，为了与SystemV兼容，目前systemd自动处理/etc/fstab并转化为mount

• automount 自动挂载点

• swap 配置交换分区

• target 配置单元的逻辑分组，包含多个相关的配置单元，可以当成是SystemV中的运行级。

• timer 定时器。用来定时触发用户定义的操作，它可以用来取代传统的atd，crond等。

• snapshot 与target类似，表示当前的运行状态

每一个配置单元都有一个对应的配置文件，系统管理员的任务就是编写和维护这写不同的配置文件，比如一个MysqL服务对应一个MysqL.service文件。

（2）依赖关系

systemd并不能完全解除各个单元之间的依赖关系，如物理设备单元准备就绪之前，不可能执行挂载单元。为此需要定义各个单元之间的依赖关系。有依赖的地方就会有出现死循环的可能，比如A依赖于B，B依赖于C，C依赖于A，那么导致死锁。systemd为此提供了两种不同程度的依赖关系，一个是require，一个是want，出现死循环时，systemd会尝试忽略want类型的依赖，如仍不能解锁，那么systemd报错。

（3)Target和runlevel

前面说过，systemd使用target取代了systemV的运行级的概念。

表 1. Sysvinit 运行级别和 systemd 目标的对应表

#cat/etc/system/system/sshd.service
[Unit]
Description=OpenSSHserverdaemon
[Service]
EnvironmentFile=/etc/sysconfig/sshd
ExecStartPre=/usr/sbin/sshd-keygen
ExecStart=/usrsbin/sshd�CD$OPTIONS
ExecReload=/bin/kill�CHUP$MAINPID
KillMode=process
Restart=on-failure
RestartSec=42s
[Install]
WantedBy=multi-user.target

#catmulti-user.target
[Unit]
Description=multi-userSystem
Documentation=man.systemd.special(7)
Requires=basic.target
Conflicts=rescue.servicerescure.target
After=basic.targetrescue.servicerescue.target
AllowIsolate=yes
[Install]
Alias=default.target

#catsys-kernel-debug.mount
[Unit]
Description=DebugFileSyste
DefaultDependencies=no
ConditionPathExists=/sys/kernel/debug
Before=sysinit.target
[Mount]
What=debugfs
Where=/sys/kernel/debug
Type=debugfs