Flask拾遺總匯1

来源:https://www.cnblogs.com/fengqiang626/archive/2019/11/22/11913984.html
-Advertisement-
Play Games

[TOC] flask依賴wsgi,實現wsgi的模塊：wsgiref,werkzeug,uwsgi 1.flask的路由分發方式 路由分發的本質：將url和視圖函數封裝成一個Rule對象，添加到Flask的url_map欄位中 2.請求響應相關 3.flask配置文件拾遺(config) from ...


目錄

flask依賴wsgi,實現wsgi的模塊：wsgiref,werkzeug,uwsgi

1.flask的路由分發方式

路由分發的本質：將url和視圖函數封裝成一個Rule對象，添加到Flask的url_map欄位中

方式一：
  @app.route('/xxxx')  # @decorator
  def index():
     return "Index"
方式二：
  def index():
     return "Index"
  app.add_url_rule('/xxx', "n1", index)  #n1是別名

2.請求響應相關

- request
    - request.form   #POST請求
    - request.args   #GET請求  字典形式的
    - request.querystring  #GET請求，bytes形式的
- response
    - return render_tempalte()
    - return redirect()
    - return ""
    v = make_response(返回值)  #吧返回的值包在了這個函數裡面
- session
    - 存在瀏覽器上，並且是加密的
    - 依賴於：secret_key

3.flask配置文件拾遺(config)

方式一：
     app.config['DEBUG'] = True
  
     PS： 由於Config對象本質上是字典，所以還可以使用app.config.update(...)
  
方式二：
     app.config.from_pyfile("python文件名稱")
     如：
     settings.py
        DEBUG = True
  
     app.config.from_pyfile("settings.py")方式三：
 import os  os.environ['FLAKS-SETTINGS'] = 'settings.py' app.config.from_envvar('FLAKS-SETTINGS') 方法四：　見下方from_object用法
app.config.from_envvar("環境變數名稱")
#環境變數的值為python文件名稱名稱，內部調用from_pyfile方法
  
app.config.from_json("json文件名稱")
#JSON文件名稱，必須是json格式，因為內部會執行json.loads
  
app.config.from_mapping({'DEBUG':True})
#字典格式

from_object用法：

app.config.from_object("python類或類的路徑")
 
app.config.from_object('pro_flask.settings.TestingConfig')
 
     settings.py

          class Config(object):
               DEBUG = False
             TESTING = False
               DATABASE_URI = 'sqlite://:memory:'

          class ProductionConfig(Config):
               DATABASE_URI = 'mysql://user@localhost/foo'

          class DevelopmentConfig(Config):
               DEBUG = True

          class TestingConfig(Config):
               TESTING = True
 
 PS: 從sys.path中已經存在路徑開始寫
     
 PS: settings.py文件預設路徑要放在程式root_path目錄，如果instance_relative_config為True，則就是instance_path目錄

current_app用法：

要想在視圖函數中獲取配置文件的值，都是通過app.config來拿。但是如果視圖函數和Flask創建的對象app不在一個模塊。就得

導入來拿。可以不用導入。直接導入一個current_app，這個就是當前的app對象，用current_app.config就能查看到了當前app的所有的配置文件

from flask import Flask,current_app
@app.route('/index',methods=["GET","POST"])
def index():
    print(current_app.config)   #當前的app的所有配置
    session["xx"] = "fdvbn"
    return "index"

4.路由系統參數配置

4.1 可傳入參數：

@app.route('/user/<username>')   #常用的   不加參數的時候預設是字元串形式的
@app.route('/post/<int:post_id>')  #常用的   #指定int，說明是整型的
@app.route('/post/<float:post_id>')
@app.route('/post/<path:path>')
@app.route('/login', methods=['GET', 'POST'])

4.2 常用路由系統有以上五

所有的路由系統都是基於一下對應關係來處理：

DEFAULT_CONVERTERS = {
    'default':          UnicodeConverter,
    'string':           UnicodeConverter,
    'any':              AnyConverter,
    'path':             PathConverter,
    'int':              IntegerConverter,
    'float':            FloatConverter,
    'uuid':             UUIDConverter,
}

5.反向生成URL： url_for

endpoint("name") #別名，相當於django中的name

反向解析需要導入：

from flask import Flask, url_for

@app.route('/index',endpoint="xxx")  #endpoint是別名
def index():
    v = url_for("xxx")
    print(v)
    return "index"

@app.route('/zzz/<int:nid>',endpoint="aaa")  #endpoint是別名
def zzz(nid):
    v = url_for("aaa",nid=nid)
    print(v)
    return "index2"

@app.route和app.add_url_rule參數:

# @app.route和app.add_url_rule參數：
            rule,                       # URL規則
            view_func,                  # 視圖函數名稱
            defaults=None,              # 預設值,當URL中無參數，函數需要參數時，使用defaults={'k':'v'}為函數提供參數
            endpoint=None,              # 名稱，用於反向生成URL，即： url_for('名稱')
            methods=None,               # 允許的請求方式，如：["GET","POST"]
            

            strict_slashes=None,        # 對URL最後的 / 符號是否嚴格要求，
                                        # 如：
                                            # @app.route('/index',strict_slashes=False)，
                                                # 訪問 http://www.xx.com/index/ 或 http://www.xx.com/index均可
                                            # @app.route('/index',strict_slashes=True)
                                                # 僅訪問 http://www.xx.com/index 
            redirect_to=None,           # 重定向到指定地址
                                        # 如：
                                            # @app.route('/index/<int:nid>', redirect_to='/home/<nid>')
                                            # 或
                                            # def func(adapter, nid):
                                                # return "/home/888"
                                            # @app.route('/index/<int:nid>', redirect_to=func)

            subdomain=None,             # 子功能變數名稱訪問
            from flask import Flask, views, url_for

            app = Flask(import_name=__name__)
            app.config['SERVER_NAME'] = 'wxs.com:5000'


            @app.route("/", subdomain="admin")
            def static_index():
                """Flask supports static subdomains
                                                    This is available at static.your-domain.tld"""
                return "admin.xxx.com"

            #動態生成
            @app.route("/dynamic", subdomain="<username>")
            def username_index(username):
                """Dynamic subdomains are also supported
                                                    Try going to user1.your-domain.tld/dynamic"""
                return username + ".your-domain.tld"


            if __name__ == '__main__':
                app.run()
        # 所有的功能變數名稱都得與IP做一個功能變數名稱解析：
　　　　　　　　# 如果你想通過功能變數名稱去訪問，有兩種解決方式：
　　　　　　　　　　# 方式一：
　　　　　　　　　　　　# 1、租一個功能變數名稱   wxs.lalala
　　　　　　　　　　　　# 2、租一個公網IP  49.8.5.62
　　　　　　　　　　　　# 3、功能變數名稱解析：
                           # wxs.com    49.8.5.62
　　　　　　　　　　　　# 4、吧代碼放在49.8.5.62這個伺服器上，程式運行起來
　　　　　　　　　　　　　 # 用戶可以通過IP進行訪問
　　　　　　　　　　# 方式二：如果是自己測試用的就可以用這種方式。先在自己本地的文件中找
　　　　　　　　　　　　# C:\Windows\System32\drivers\etc  找到HOST，修改配置
　　　　　　　　　　　　# 然後吧功能變數名稱修改成自己的本地伺服器127.0.0.1
　　　　　　　　　　　　# 加上配置：app.config["SERVER_NAME"] = "wxs.com:5000"

功能變數名稱(subdomain)訪問實例：

# =============== 子功能變數名稱訪問============
@app.route("/static_index", subdomain="admin")
def static_index():
    return "admin.bjg.com"

# ===========動態生成子功能變數名稱===========
@app.route("/index",subdomain='<xxxxx>')
def index(xxxxx):
    return "%s.bjg.com" %(xxxxx,)

6.flask路由系統的正則匹配配置

擴展Flask的路由系統，讓他支持正則,這個類必須這樣寫，必須去繼承BaseConverter

from flask import Flask,url_for

    app = Flask(__name__)

    # 定義轉換的類
    from werkzeug.routing import BaseConverter
    class RegexConverter(BaseConverter):
        """
        自定義URL匹配正則表達式
        """

        def __init__(self, map, regex):
            super(RegexConverter, self).__init__(map)
            self.regex = regex

        def to_python(self, value):
            """
            路由匹配時，匹配成功後傳遞給視圖函數中參數的值
            :param value: 
            :return: 
            """
            return int(value)

        def to_url(self, value):
            """
            使用url_for反向生成URL時，傳遞的參數經過該方法處理，返回的值用於生成URL中的參數
            :param value: 
            :return: 
            """
            val = super(RegexConverter, self).to_url(value)
            return val

    # 添加到converts中
    app.url_map.converters['regex'] = RegexConverter

    # 進行使用
    @app.route('/index/<regex("\d+"):nid>',endpoint='xx')
    def index(nid):
        url_for('xx',nid=123)  #反向生成，就會去執行to_url方法
        return "Index"

    if __name__ == '__main__':
        app.run()

7.Flask中的CBV模式

def auth(func):
            def inner(*args, **kwargs):
                result = func(*args, **kwargs)
                return result
            return inner

        class IndexView(views.MethodView):
            # methods = ['POST']  #只允許POST請求訪問
            decorators = [auth,]  #如果想給所有的get,post請求加裝飾器，就可以這樣來寫，也可以單個指定
  
            def get(self):   #如果是get請求需要執行的代碼
                v = url_for('index')
                print(v)
                return "GET"

            def post(self):  #如果是post請求執行的代碼
                return "POST"

        app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  #name指定的是別名，會當做endpoint使用

        if __name__ == '__main__':
            app.run()

8.Flask中的FBV模式

方式一：
    @app.route('/index',endpoint='xx')
    def index(nid):
        url_for('xx',nid=123)
        return "Index"

方式二：
    def index(nid):
        url_for('xx',nid=123)
        return "Index"

    app.add_url_rule('/index',index)

9.Flask中的請求與相應

 1 from flask import Flask
 2     from flask import request
 3     from flask import render_template
 4     from flask import redirect
 5     from flask import make_response
 6 
 7     app = Flask(__name__)
 8 
 9 
10     @app.route('/login.html', methods=['GET', "POST"])
11     def login():
12 
13         # 請求相關信息
14         # request.method
15         # request.args
16         # request.form
17         # request.values
18         # request.cookies
19         # request.headers
20         # request.path
21         # request.full_path
22         # request.script_root
23         # request.url
24         # request.base_url
25         # request.url_root
26         # request.host_url
27         # request.host
28         # request.files
29         # obj = request.files['the_file_name']
30         # obj.save('/var/www/uploads/' + secure_filename(f.filename))
31 
32         # 響應相關信息
33         # return "字元串"
34         # return render_template('html模板路徑',**{})
35         # return redirect('/index.html')
36 
37         # response = make_response(render_template('index.html'))
38         # response是flask.wrappers.Response類型
39         # response.delete_cookie('key')
40         # response.set_cookie('key', 'value')
41         # response.headers['X-Something'] = 'A value'
42         # return response
43 
44 
45         return "內容"
46 
47     if __name__ == '__main__':
48         app.run()

請求與相應詳解

from flask import Flask,url_for,request,redirect,render_template,jsonify,make_response
from urllib.parse import urlencode,quote,unquote
app = Flask(__name__)

@app.route('/index',endpoint='xx')
def index():
    from werkzeug.datastructures import ImmutableMultiDict
　　=================
    # get_data = request.args
    # get_dict = get_data.to_dict()
    # get_dict['xx'] = '18'
    # url = urlencode(get_dict)
    # print(url)
　　====================
    # print(request.query_string)
    # print(request.args)
　　==========================
    # val = "%E6%8A%8A%E5%87%A0%E4%B8%AA"
    # print(unquote(val))   #吧上面這樣的數據轉換成中文
    #
    # return "Index"

    # return "Index"
    # return redirect()
    # return render_template()
    # return jsonify(name='alex',age='18')  #相當於JsonResponse
　　=======================
    response = make_response('xxxxx')   #如果是返回更多的值，cookie，headers，或者其他的就可用它
    response.headers['xxx'] = '123123'
    return response


if __name__ == '__main__':
    # app.__call__
    app.run()

10.Flask模板語法(jinja2)

template_global和template_filter用法：

調用方式：{{sb(1,2)}} {{ 1|db(2,3)}}

@app.template_global()
def sb(a1, a2):
    return a1 + a2


@app.template_filter()
def db(a1, a2, a3):
    return a1 + a2 + a3

11.session

除請求對象之外，還有一個 session 對象。它允許你在不同請求間存儲特定用戶的信息。它是在 Cookies 的基礎上實現的，並且對 Cookies 進行密鑰簽名要使用會話，你需要設置一個密鑰。

  • 設置：session['username'] ＝ 'xxx'
  • 刪除：session.pop('username', None)
from flask import Flask,url_for,session

app = Flask(__name__)
app.secret_key = "sdsfdgdgdgd"
app.config['SESSION_COOKIE_NAME'] = 'session_lvning'  #設置session的名字

@app.route('/index/')
def index(nid):
    #session本質上操作的是字典， session是否還有其他方法？與字典方法相同
    #session的原理：如果下一次訪問的時候帶著隨機字元串，會把session裡面對應的
    # 值拿到記憶體，假設session保存在資料庫，每執行一次鏈接一次資料庫，每次都要時時更新的話
    # 會非常損耗記憶體
    session["xxx"] = 123
    session["xxx2"] = 123
    session["xxx3"] = 123
    session["xxx4"] = 123
    del session["xxx2"]  #在這刪除了，真正存儲的時候是沒有xxx2的
    return "ddsf"

if __name__ == '__main__':
    app.run()

關於session的配置

app.config['SESSION_COOKIE_NAME'] = 'session_lvning'
- session超時時間如何設置？      'PERMANENT_SESSION_LIFETIME':           timedelta(days=31)
 以下是跟session相關的配置文件
"""
            'SESSION_COOKIE_NAME':                  'session',
            'SESSION_COOKIE_DOMAIN':                None,
            'SESSION_COOKIE_PATH':                  None,
            'SESSION_COOKIE_HTTPONLY':              True,
            'SESSION_COOKIE_SECURE':                False,
            'SESSION_REFRESH_EACH_REQUEST':         True,  #是否每次都跟新
            'PERMANENT_SESSION_LIFETIME':           timedelta(days=31)
 1 from flask import Flask, session, redirect, url_for, escape, request
 2  
 3 app = Flask(__name__)
 4  
 5 @app.route('/')
 6 def index():
 7     if 'username' in session:
 8         return 'Logged in as %s' % escape(session['username'])
 9     return 'You are not logged in'
10  
11 @app.route('/login', methods=['GET', 'POST'])
12 def login():
13     if request.method == 'POST':
14         session['username'] = request.form['username']
15         return redirect(url_for('index'))
16     return '''
17         <form action="" method="post">
18             <p><input type=text name=username>
19             <p><input type=submit value=Login>
20         </form>
21     '''
22  
23 @app.route('/logout')
24 def logout():
25     # remove the username from the session if it's there
26     session.pop('username', None)
27     return redirect(url_for('index'))
28  
29 # set the secret key.  keep this really secret:
30 app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'

自定義session:

  1 pip3 install Flask-Session
  2         
  3         run.py
  4             from flask import Flask
  5             from flask import session
  6             from pro_flask.utils.session import MySessionInterface
  7             app = Flask(__name__)
  8 
  9             app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
 10             app.session_interface = MySessionInterface()
 11 
 12             @app.route('/login.html', methods=['GET', "POST"])
 13             def login():
 14                 print(session)
 15                 session['user1'] = 'alex'
 16                 session['user2'] = 'alex'
 17                 del session['user2']
 18 
 19                 return "內容"
 20 
 21             if __name__ == '__main__':
 22                 app.run()
 23 
 24         session.py
 25             #!/usr/bin/env python
 26             # -*- coding:utf-8 -*-
 27             import uuid
 28             import json
 29             from flask.sessions import SessionInterface
 30             from flask.sessions import SessionMixin
 31             from itsdangerous import Signer, BadSignature, want_bytes
 32 
 33 
 34             class MySession(dict, SessionMixin):
 35                 def __init__(self, initial=None, sid=None):
 36                     self.sid = sid
 37                     self.initial = initial
 38                     super(MySession, self).__init__(initial or ())
 39 
 40 
 41                 def __setitem__(self, key, value):
 42                     super(MySession, self).__setitem__(key, value)
 43 
 44                 def __getitem__(self, item):
 45                     return super(MySession, self).__getitem__(item)
 46 
 47                 def __delitem__(self, key):
 48                     super(MySession, self).__delitem__(key)
 49 
 50 
 51 
 52             class MySessionInterface(SessionInterface):
 53                 session_class = MySession
 54                 container = {}
 55 
 56                 def __init__(self):
 57                     import redis
 58                     self.redis = redis.Redis()
 59 
 60                 def _generate_sid(self):
 61                     return str(uuid.uuid4())
 62 
 63                 def _get_signer(self, app):
 64                     if not app.secret_key:
 65                         return None
 66                     return Signer(app.secret_key, salt='flask-session',
 67                                   key_derivation='hmac')
 68 
 69                 def open_session(self, app, request):
 70                     """
 71                     程式剛啟動時執行，需要返回一個session對象
 72                     """
 73                     sid = request.cookies.get(app.session_cookie_name)
 74                     if not sid:
 75                         sid = self._generate_sid()
 76                         return self.session_class(sid=sid)
 77 
 78                     signer = self._get_signer(app)
 79                     try:
 80                         sid_as_bytes = signer.unsign(sid)
 81                         sid = sid_as_bytes.decode()
 82                     except BadSignature:
 83                         sid = self._generate_sid()
 84                         return self.session_class(sid=sid)
 85 
 86                     # session保存在redis中
 87                     # val = self.redis.get(sid)
 88                     # session保存在記憶體中
 89                     val = self.container.get(sid)
 90 
 91                     if val is not None:
 92                         try:
 93                             data = json.loads(val)
 94                             return self.session_class(data, sid=sid)
 95                         except:
 96                             return self.session_class(sid=sid)
 97                     return self.session_class(sid=sid)
 98 
 99                 def save_session(self, app, session, response):
100                     """
101                     程式結束前執行，可以保存session中所有的值
102                     如：
103                         保存到resit
104                         寫入到用戶cookie
105                     """
106                     domain = self.get_cookie_domain(app)
107                     path = self.get_cookie_path(app)
108                     httponly = self.get_cookie_httponly(app)
109                     secure = self.get_cookie_secure(app)
110                     expires = self.get_expiration_time(app, session)
111 
112                     val = json.dumps(dict(session))
113 
114                     # session保存在redis中
115                     # self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime)
116                     # session保存在記憶體中
117                     self.container.setdefault(session.sid, val)
118 
119                     session_id = self._get_signer(app).sign(want_bytes(session.sid))
120 
121                     response.set_cookie(app.session_cookie_name, session_id,
122                                         expires=expires, httponly=httponly,
123                                         domain=domain, path=path, secure=secure)

第三方flask-session應用：

session存在在服務端的一個字典裡面，session保存起來，取一次裡面還是有的，直到你刪除之後才沒有了

from flask import Flask, session, render_template, request, views

from flask_session import Session
from redis import Redis

app = Flask(__name__)
app.default_config()

app.config["SESSION_TYPE"] = "redis"
app.config["SESSION_REDIS"] = Redis(host="127.0.0.1", port=6379, db=0)

app.templates_auto_reload = True

# 使用第三方flask-session，封裝app這個實例化對象
Session(app)

userinfo = {"user": "alex", "pwd": "123"}


class Login(views.MethodView):
    methods = ["POST", "GET"]

    def get(self):
        return render_template("login.html")

    def post(self):
        user = request.form.get("username")
        pwd = request.form.get("pwd")

        if user == userinfo["user"] and pwd == userinfo["pwd"]:
            # 創建session
            session["user"] = user
            return "登錄成功！"
        else:
            return "登錄失敗！"


app.add_url_rule("/login", endpoint=None, view_func=Login.as_view(name="login"))

if __name__ == '__main__':
    app.run()

12.閃現 : flash

本質：flash是基於session創建的，flash支持往裡邊放值，只要你取一下就沒有了，相當於pop了一下。不僅把值取走，而且把session里的東西去掉

from flask import Flask,session,Session,flash,get_flashed_messages,redirect,render_template,request
app = Flask(__name__)
app.secret_key ='sdfsdfsdf'

@app.route('/users')
def users():
    # 方式一
    # msg = request.args.get('msg','')
    # 方式二
    # msg = session.get('msg')
    # if msg:
    #     del session['msg']
    # 方式三
    v = get_flashed_messages()
    print(v)
    msg = ''
    return render_template('users.html',msg=msg)

@app.route('/useradd')
def user_add():
    # 在資料庫中添加一條數據
    # 假設添加成功，在跳轉到列表頁面時，顯示添加成功
    # 方式一
    # return redirect('/users?msg=添加成功')
    # 方式二
    # session['msg'] = '添加成功'
    # 方式三
    flash('添加成功')
    return redirect('/users')


if __name__ == '__main__':
    app.run(debug=True)

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Java描述設計模式(21)：狀態模式
    本文源碼： "GitHub·點這裡" || "GitEE·點這裡" 一、生活場景 1、場景描述 變色龍是爬行動物，是非常奇特的動物，它有適於樹棲生活的種種特征和行為，身體也會隨著環境的變化而變化出適應環境的顏色，非常神奇。下麵基於狀態模式對該變化過程進行描述。 2、代碼實現 二、狀態模式 1、基礎概 ...
  • Java實現Kafka的生產者和消費者例子
    Kafka的結構與RabbitMQ類似，消息生產者向Kafka伺服器發送消息，Kafka接收消息後，再投遞給消費者。 生產者的消費會被髮送到Topic中，Topic中保存著各類數據，每一條數據都使用鍵、值進行保存。 每一個Topic中都包含一個或多個物理分區（Partition），分區維護著消息... ...
  • 詳解Redis RDB持久化、AOF持久化
    1.持久化 1.1 持久化簡介 持久化（Persistence），持久化是將程式數據在持久狀態和瞬時狀態間轉換的機制，即把數據（如記憶體中的對象）保存到可永久保存的存儲設備中（如磁碟）。 1.2 redis持久化 redis為記憶體資料庫，為了防止伺服器宕機以及伺服器進程退出後，伺服器數據丟失，Redi ...
  • PHP 核心特性 - 錯誤處理
    錯誤與異常 錯誤，可以理解程式本身的錯誤，例如語法錯誤。而異常則更偏向於程式運行不符合預期或者不符合正常流程；對於 PHP 語言而言，處理錯誤和處理異常使用的機制完全不同，因此很容易讓人產生困惑。 例如，我們希望通過捕獲異常來處理除數為 0 的情況，但是在捕獲到異常之前，PHP 就觸發了錯誤。 1 ...
  • 深入理解AbstractQueuedSynchronizer(AQS)
    在上一篇文章中我們對lock和AbstractQueuedSynchronizer(AQS)有了初步的認識。在同步組件的實現中，AQS是核心部分，同步組件的實現者通過使用AQS提供的模板方法實現同步組件語義，AQS則實現了對同步狀態的管理，以及對阻塞線程進行排隊，等待通知等等一些底層的實現處理。AQ... ...
  • C基礎 帶你手寫 redis adlist 雙向鏈表
    引言 - 導航欄目 有些朋友可能對 redis 充滿著數不盡的求知欲, 也許是 redis 屬於工作, 交流(面試)的大頭戲, 不得不 ... 而自己當下對於 redis 只是停留在會用層面, 細節層面幾乎沒有涉獵. 為了更快的融於大 家, 這裡嘗試拋磚引玉. 先帶大家手寫個 redis 中最簡單的 ...
  • 自學的Python找工作的難度多大？
    隨著Python語言的生態日漸完善，採用Python開發方案的團隊也在增加，而且Python由於自身語法的特點和豐富的庫支持，一直比較受程式員群體的歡迎，這也是Python得到大量應用的重要原因之一。所以，從就業的角度來看，當前學習Python是不錯的選擇，但是找工作的難度呢？ 如果想通過自學Pyt ...
  • [Go] 利用有緩存channel控制同時併發的數量
    如果有一個大迴圈,裡面每一個都開啟groutine,那麼瞬間就會開啟非常多的groutine,要解決這個問題就要用channel的阻塞特性來解決 看時間每次只是同時執行兩個 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類