全部问题

这是一个最低限度可重现的示例：

namespace IterableDisposeTest
{
  interface IInstance
  {
    int ID { get; }
  }

  class Instance : IInstance
  {
    private static int p_counter = 0;

    public int ID { get; }

    public Instance(MagicVariable _magicVariable)
    {
      ID = p_counter++;
      Console.WriteLine(_magicVariable.MagicString);
    }
  }

  interface IProducer
  {
    public IEnumerable<IInstance> GetNextInstance();
  }
  
   
  class Producer : IProducer
  {
    private MagicVariable p_magicVariable;

    public Producer(MagicVariable _magicVariable)
    {
      p_magicVariable = _magicVariable;
    }

    public IEnumerable<IInstance> GetNextInstance()
    {
      for (int i = 0; i < 42; i++)
        yield return new Instance(p_magicVariable);
    }
  }

  class ProducerFactory: IDisposable
  {
    private bool disposedValue;
    private MagicVariable p_magicVariable = new MagicVariable();

    public IEnumerable<Producer> GetNextProducer()
    {
      while (true)
        yield return new Producer(p_magicVariable);
    }

    protected virtual void Dispose(bool disposing)
    {
      if (!disposedValue)
      {
        Console.WriteLine("ProducerFactory Disposed");
        if (disposing)
        {

        }

        p_magicVariable.Dispose();
        disposedValue = true;
      }
    }

    ~ProducerFactory()
    {
      Dispose(disposing: false);
    }

    public void Dispose()
    {
      Dispose(disposing: true);
      GC.SuppressFinalize(this);
    }
  }

  class MagicVariable: IDisposable
  {
    private string p_magicString = "I'm MAGIC!";
    private bool p_disposedValue;

    public string MagicString
    {
      get
      {
        ObjectDisposedException.ThrowIf(p_disposedValue, typeof(string));
        return p_magicString;
      }
    }

    protected virtual void Dispose(bool disposing)
    {
      if (!p_disposedValue)
      {
        Console.WriteLine("MagicVariable Disposed");
        if (disposing)
        {
        }

        p_disposedValue = true;
      }
    }

    ~MagicVariable()
    {
      Dispose(disposing: false);
    }

    public void Dispose()
    {
      Dispose(disposing: true);
      GC.SuppressFinalize(this);
    }
  }

  static class SuperProducer
  {
    public static IEnumerable<IProducer> GetNextProducer()
    {
      using ProducerFactory factory = new ProducerFactory();
      foreach(var producer in factory.GetNextProducer())
        yield return producer;
    }
  }

  internal class Program
  {
    static void Main(string[] args)
    {
      IProducer? producer = SuperProducer.GetNextProducer().FirstOrDefault((IProducer?)null);
      if (producer != null)
      {
        // Thrown ObjectDisposedException there:
        foreach (IInstance instance in producer.GetNextInstance())
          Console.WriteLine($"Instance id is: {instance.ID}");
      }
    }
  }
}

它会导致异常ObjectDisposedException，因为工厂在第 124 行退出语句时被释放。using困境如下 - 只有当语句中没有创建工厂时，错误才会消失using，但这与 RAII 概念相矛盾，工厂不会被创建。释放。如果你在 - 中创建一个工厂，那么它会在从第 126 行的循环using返回之前被释放。请告诉我这个示例中的架构错误是什么？IProducer你能怎样解决它？

template <typename T>
struct MyT {};

template <typename T>
constexpr bool std::is_void_v<MyT<T>> = true;

static_assert(std::is_void_v<MyT<int>>);

在clang和gcc 中static_assert正常工作。但msvc认为，is_void_v仍然是false。

https://godbolt.org/z/9r6YeaM91

我已经遇到过这样一个事实：在msvc中，有些事情的行为与纯 C++ 中的行为并不完全相同，但据我所知，可以使用编译器指令来调节这一点。也许这里也有一些指令？或者这纯粹是一个错误（功能））））？那么，或者如何将它们重新加载到msvc中？

再会。我正在尝试（学习）抓取该网站。有数据（有很多这样的带有数据的行，大约28-30个单位）。

    <div class="maxt">
    <temperature-value value="-12" from-unit="c" reactive="">−12</temperature-value>
    </div>

我通过 BeautifulSoup 获取字符串。

maxt = bs.find_all('div', class_= "maxt")

这些线条本身是正确的。

无法从这一行获取值：-12 对于所有内容。

告诉我出了什么问题。

我设法这样做，但也许我可以通过“find...find_all”来做到这一点

temp_list = []
for t in temp:
    temperatyre = t['value']
    if temperatyre != '':
        print(t['value'])
        temp_list.append(temperatyre)

此外，代码可以工作，但选择并不令人满意（它选择了所有温度，但例如只需要 maxt 和 mint）

import requests
from bs4 import BeautifulSoup
 
url = 'https://www.gismeteo.ru/weather-omsk-4578/month/'
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",}

response = requests.get(url, headers=headers)

bs = BeautifulSoup(response.text, 'lxml')
temp = bs.find_all('temperature-value')

print('всего строк = ' + str(len(temp)))

temp_list = []

for t in temp:
    temperatyre = t['value']
    if temperatyre != '':
        print(t['value'])
        temp_list.append(temperatyre)

有一个数据框表：

      BSC Reg  BS_number
0  12  SA        135
1  12  SA        135
2  12  SA        135
3  39853  SA        620
4  39853  SA        620
5  39853  SA        620
6  39853  SA        621
7  39853  SA        621
8  39853  SA        621

和字典：

{'89118': 'BR067', '28': 'IR028', '120': 'IK120', '39602': 'IK135', '40877': 'IR148', '40157': 'IR169', '40256': 'IK395', '41255': 'IR484', '39493': 'KM070', '91222': 'KH173', '39428': 'KH174', '38471': 'MG069', '34697': 'NS042', '18': 'IR138', '39853': 'SA068', '12': 'SH102'}

如何用Python中的字典中的值替换BSC列中的数据？也就是说，以这种方式获取表格：

      BSC Reg  BS_number
0  SA102  SA        135
1  SA102  SA        135
2  SA102  SA        135
3  SA068  SA        620
4  SA068  SA        620
5  SA068  SA        620
6  SA068  SA        621
7  SA068  SA        621
8  SA068  SA        621

我无法弄清楚错误可能出在哪里。

订单.java:

package com.example.demo.model;

import jakarta.persistence.*;

@Entity
@Table(name = "orders")
public class Order {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    @Column(name = "customer")
    private String customer;

    @Column(name = "description")
    private String description;

    @Column(name = "price")
    private short price;

    @Column(name = "readiness")
    private boolean readiness;

    public Order() {

    }

    public Order(String customer, String description, short price, boolean readiness) {
        this.customer = customer;
        this.description = description;
        this.price = price;
        this.readiness = readiness;
    }

    public long getId() {
        return id;
    }

    public String getCustomer() {
        return customer;
    }

    public void setCustomer(String customer) {
        this.customer = customer;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public short getPrice() {
        return price;
    }

    public void setPrice(short price) {
        this.price = price;
    }

    public boolean isReady() {
        return readiness;
    }

    public void setReadiness(boolean isReady) {
        this.readiness = isReady;
    }

    @Override
    public String toString() {
        return "Order [id=" + id + ", customer=" + customer + ", desc=" + description + ", readiness=" + readiness + "]";
    }
}

订单控制器.java：

package com.example.demo.controller;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.example.demo.model.Order;
import com.example.demo.repository.OrderRepository;

@CrossOrigin(origins = "http://localhost:8081")
@RestController
@RequestMapping("/api")
public class OrderController {

    @Autowired
    OrderRepository orderRepository;

    @GetMapping("/orders")
    public ResponseEntity<List<Order>> getAllOrders(@RequestParam(required = false) String customer) {
        try {
            List<Order> orders = new ArrayList<Order>();

            if (customer == null)
                orderRepository.findAll().forEach(orders::add);
            else
                orderRepository.findByCustomerContaining(customer).forEach(orders::add);

            if (orders.isEmpty()) {
                return new ResponseEntity<>(HttpStatus.NO_CONTENT);
            }

            return new ResponseEntity<>(orders, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @GetMapping("/orders/{id}")
    public ResponseEntity<Order> getOrderById(@PathVariable("id") long id) {
        Optional<Order> orderData = orderRepository.findById(id);

        if (orderData.isPresent()) {
            return new ResponseEntity<>(orderData.get(), HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @PostMapping("/orders")
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        try {
            Order _order = orderRepository
                    .save(new Order(order.getCustomer(), order.getDescription(), order.getPrice(), false));
            return new ResponseEntity<>(_order, HttpStatus.CREATED);
        } catch (Exception e) {
            return new ResponseEntity<>(null, HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @PutMapping("/orders/{id}")
    public ResponseEntity<Order> updateOrder(@PathVariable("id") long id, @RequestBody Order order) {
        Optional<Order> orderData = orderRepository.findById(id);

        if (orderData.isPresent()) {
            Order _order = orderData.get();
            _order.setCustomer(order.getCustomer());
            _order.setDescription(order.getDescription());
            _order.setReadiness(order.isReady());
            return new ResponseEntity<>(orderRepository.save(_order), HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @DeleteMapping("/orders/{id}")
    public ResponseEntity<HttpStatus> deleteOrder(@PathVariable("id") long id) {
        try {
            orderRepository.deleteById(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @DeleteMapping("/orders")
    public ResponseEntity<HttpStatus> deleteAllOrders() {
        try {
            orderRepository.deleteAll();
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

    @GetMapping("/orders/readiness")
    public ResponseEntity<List<Order>> findByPublished() {
        try {
            List<Order> orders = orderRepository.findByrReadiness(true);

            if (orders.isEmpty()) {
                return new ResponseEntity<>(HttpStatus.NO_CONTENT);
            }
            return new ResponseEntity<>(orders, HttpStatus.OK);
        } catch (Exception e) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

订单存储库.java：

package com.example.demo.repository;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;

import com.example.demo.model.Order;

public interface OrderRepository extends JpaRepository<Order, Long>{

    List<Order> findByrReadiness(boolean readiness);

    List<Order> findByCustomerContaining(String customer);
}

应用程序属性：

spring.application.name=demo

spring.datasource.url= jdbc:postgresql://localhost:5432/dry_cleaning
spring.datasource.username= postgres
spring.datasource.password= 1234
server.port=8081

spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation= true
spring.jpa.properties.hibernate.dialect= org.hibernate.dialect.PostgreSQLDialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto= update

pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>3.4.0</version>
       <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.example</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   <url/>
   <licenses>
       <license/>
   </licenses>
   <developers>
       <developer/>
   </developers>
   <scm>
       <connection/>
       <developerConnection/>
       <tag/>
       <url/>
   </scm>
   <properties>
       <java.version>17</java.version>
   </properties>
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-data-jpa</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>

       <dependency>
           <groupId>org.postgresql</groupId>
           <artifactId>postgresql</artifactId>
           <scope>runtime</scope>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>

</project>